Eseguire chiamate AJAX con jQuery e JSON in WordPress

Ajax and WordPress

Succede sempre più di frequente di dover effettuare delle chiamate ajax in WordPress. In questo articolo vedremo come effettuare delle chiamate asincrone senza dover creare nuove pagine WordPress ma sfruttando lo script utilizzato dall’interfaccia del wp-admin.
Nell’esempio in questione, la chiamata AJAX restituirà un file JSON formato davvero utile per rappresentare i dati restituiti da una query. Lato javascript useremo la funzione $.getJSON(…) di jQuery mentre lato server scriveremo il nostro script all’interno del file functions.php presente in qualsiasi tema WordPress.

Per prima cosa dobbiamo creare la corrispondenza tra una nuova action e la nostra funzione php:

add_action('wp_ajax_myaction', 'my_function');

Fatto ciò possiamo scrivere la nostra funzione my_function la quale corrisponderà all’azione myaction (il nome è puramente indicativo, potete chiamare l’azione e la funzione come preferite):

function my_function() {
  global $wpdb;
  $id = $_GET['id'];
  $rows = array();
  $q = "SELECT * FROM my_table WHERE id = ".$id;
  $rows['results'] = $wpdb->get_results($q, ARRAY_A);
  if(count($rows) <= 0){
    return false;
  }
  echo json_encode($rows);
  exit();
}

In questo script trovate tutto l’indispensabile per completare la parte lato server. Come si può intuire la query dovrà utilizzare un parametro passato in GET, poi utilizzando la variabile globale wpdb effettueremo la query sul database. La json_encode trasformerà l’array associativo con i record letti tramite la SELECT in una stringa JSON e la stamperemo a video tramite l’echo. Non dimenticate la exit() finale perchè altrimenti verrà stampato uno “0” che vi metterà in difficoltà nel parsificare il JSON.

Un ultimo particolare di cui tenere conto è che la add_action crea un’azione per l’admin-ajax.php che è un file accessibile solo da utenti loggati, quindi per consentire l’esecuzione dell’azione sia da utenti registrati sia da ospiti sarà necessario aggiungere un’ulteriore linea di codice come questa:

add_action('wp_ajax_nopriv_myaction', 'my_function');

Dopo aver completato lo script PHP possiamo passare al lato client, con il codice javascript per la chiamata della funzione:

$jQ.getJSON('<?php echo get_bloginfo('url'); ?>/wp-admin/admin-ajax.php',{action: 'myaction',id: 'tuo_id'}, function(json){...Codice javascript per parsificare il json...}

Ho omesso l’inclusione di jquery in WordPress, ma potete trovare come fare in un mio precedente articolo che trattava l’argomento nello specifico.

A questo punto non vi resta che sbizzarrirvi con le chiamate ajax nel vostro template oppure dai vostri plugin (in quest’ultimo caso basta spostare il codice PHP in un file del vostro plugin).

Eseguire un’applicazione Django su ubuntu server con nginx, gunicorn, upstart e mysql (DUNG stack)

Gunicorn

Oggi torno a scrivere sul blog per raccontare come eseguire il deploy di un’applicazione Django su ubuntu server con Nginx come web server, Gunicorn come application server WSGI e MySQL come DBMS.

Inizialmente per ospitare un’applicazione scritta con il framework Django utilizzavo un classico stack in stile LAMPP (Linux + Apache + mod_wsgi). Successivamente per cercare di limitare l’utilizzo di ram ho scoperto (grazie al blog degli ingegneri di instagram) lo stack DUNG che rappresenta la configurazione con nginx + gunicorn + ubuntu.

Non appena si iniziano le configurazioni si comprendono la semplicità e la velocità di messa a punto del nuovo stack. Nginx usa file di configurazione scritti con una sintassi simile ad un linguaggio di programmazione, molto più semplici da comprendere e da scrivere per chi ha poca dimestichezza con queste cose.

Per prima cosa installiamo nell’ordine mysql e nginx, successivamente installiamo django.

Fatto ciò, tramite easy_install possiamo installare Gunicorn:

sudo easy_install gunicorn

A questo punto dobbiamo configurare nginx come proxy server per le richieste: tutto ciò che riguarda i file statici (immagini, css, js, ecc…) verrà servito direttamente da nginx mentre le richieste inerenti il codice python dovranno essere girate al server WSGI (gunicorn nel nostro caso) che le eseguirà e restituirà la pagina risultante.

Come per apache i file di configurazione dei vari siti sono in /etc/nginx/sites-available (invece di /etc/apache/sites-available), per cui creiamo il file di configurazione per la nostra applicazione django in questo modo:

upstream project {
        server 127.0.0.1:8200 fail_timeout=0;
        server 127.0.0.1:8201 fail_timeout=0;
}

server {
        listen 80;
        server_name mydomain.com www.mydomain.com;
        access_log /var/log/nginx/mydomain_access.log;
        error_log /var/log/nginx/mydomain_error.log;

        root /srv/django_srv/mydomain/app;

        location / {
                proxy_set_header Host $host;
                if (!-f $request_filename){
                        proxy_pass http://project;
                        break;
                }

        }
        location /upload  {
                alias /srv/django_srv/mydomain/uploads;
                }
        location /static  {
                alias /srv/django_srv/mydomain/app/_statics;
        }
        location /admin/media {
                alias /opt/Django-1.3.1/django/contrib/admin/media;
        }
}

Come potete vedere nel blocco di configurazione upstream project a questo punto dobbiamo configurare gunicorn in modo da farlo rispondere sulla porta 8200 e 8201. In questo modo quando caricheremo aggiornamenti del nostro progetto e dovremmo riavviare gunicorn, il sito non sarà mai irraggiungibile, inoltre se il processo gunicorn dovesse crollare per qualche motivo ce ne sarà sempre un altro disponibile. Gli alias che vedete sono per i file uploadati dagli utenti tramite l’applicazione, i file statici del sito e i file statici per il backend amministrativo (per questi ultimi dovete dare il path alla cartella di installazione di Django). Dopo aver salvato questo file create un link simbolico nella cartella effettiva dei siti di nginx:

ln -s /etc/nginx/sites-available/mydomain.com /etc/nginx/sites-enabled/mydomain.com

Per avviare gunicorn, essendo su ubuntu, utilizziamo upstart il nuovo sistema per avviare tasks e servizi all’avvio del sistema. Creiamo il file /etc/init/gunicorn_8200.conf e copiamo le seguenti istruzioni:

description "Gunicorn Django on 127.0.0.1:8200"
start on runlevel [2345]
stop on runlevel [06]
respawn
respawn limit 10 5
exec /usr/local/bin/gunicorn_django --bind=127.0.0.1:8200 --workers=2 --access-logfile=/var/log/gunicorn/8200_access.log --error-logfile=/var/log/gunicorn/8200_error.log --daemon /srv/django_srv/mydomain/app/settings.py

Con queste istruzioni diciamo al processo gunicorn di ripartire in caso di crash (respawn) di rispondere all’indirizzo 127.0.0.1 sulla porta 8200 (–bind) di partire come demone (–daemon) e gli diamo i percorsi dei file di log e del file di settings della nostra applicazione.

A questo punto riavviamo il server per verificare che anche upstart funzioni:

shutdown -r now

Il gioco è fatto e la nostra applicazione è pronta per essere utilizzata. I file del progetto django (in base a questa configurazione) devono risiedere in /srv/django_srv/mydomain/app, mentre i file di upload sono in /srv/django_srv/mydomain/uploads per fare in modo che non siano all’interno dell’applicazione e che siano facilmente backuppabili ;)

Spero di essere stato esaustivo, di sicuro con questa configurazione vi potrete accorgere del notevole risparmio di ram rispetto ad un classico stack che utilizza apache come webserver.

Server virtualizzato con VirtualBox 4.0 su Ubuntu Server 10.04 LTS

Oracle Virtualbox

Oggi inauguro la nuova grafica del blog con un articolo molto interessante. Questo tutorial vi aiuterà a virtualizzare dei server con VirtualBox da linea di comando.
Ho installato virtualbox 4.0 su una macchina ubuntu server 10.04, ma repository a parte penso che vada bene su qualsiasi versione di ubuntu e più in generale su qualsiasi debian.

Per chi lavora come me su ubuntu server 10.04 per prima cosa bisogna aggiungere il repository di virtualbox nei sorgenti apt. Aprite il file source.list:

sudo vim /etc/apt/sources.list

E aggiungete in fondo la linea:

deb http://download.virtualbox.org/virtualbox/debian lucid contrib

Salvate e chiudete e scaricate la chiave pubblica:

wget -q http://download.virtualbox.org/virtualbox/debian/oracle_vbox.asc -O- | sudo apt-key add -

A questo punto aggiornate:

sudo apt-get update

..e installate il software necessario:

sudo apt-get install linux-headers-$(uname -r) build-essential virtualbox-4.0 dkms

Il pacchetto dkms serve per far sì che ogni volta che il kernel verrà aggiornato verrà aggiornato automaticamente anche virtualbox.

A questo punto scaricate l’extension pack di virtualbox

cd /tmp
wget http://download.virtualbox.org/virtualbox/4.0.16/Oracle_VM_VirtualBox_Extension_Pack-4.0.16-75491.vbox-extpack
sudo VBoxManage extpack install Oracle_VM_VirtualBox_Extension_Pack-4.0.16-75491.vbox-extpack

Ora dovrete aggiungere il vostro utente al gruppo utenti di virtualbox:

sudo adduser your_user vboxusers

Ora la configurazione di virtualbox è terminata, possiamo procedere con la creazione di una nuova virtual machine.

VBoxManage createvm --name "ubu_srv_1" --register
VBoxManage modifyvm "ubu_srv_1" --memory 512 --acpi on --boot1 dvd --nic1 bridged --bridgeadapter1 eth0
VBoxManage createhd --filename /home/your_user/vbox/ubu_srv_1/ubu_srv_1.vdi --size 10000
VBoxManage storagectl "ubu_srv_1" --name "IDE Controller" --add ide
VBoxManage storageattach "ubu_srv_1" --storagectl "IDE Controller" --port 0 --device 0 --type hdd --medium /home/your_user/vbox/ubu_srv_1/ubu_srv_1.vdi
VBoxManage storageattach "ubu_srv_1" --storagectl "IDE Controller" --port 1 --device 0 --type dvddrive --medium /home/your_user/downloads/ubuntu-10.04.4-server-amd64.iso

Con queste istruzioni la nuova macchina virtuale è pronta.

Ora per il primo lancio vi consiglio di usare VBoxHeadless che oltre a lanciare la vm appena creata metterà in piedi un server VRDP, in modo che possiate accedere alla macchina con un client di desktop remoto. Per cui, settiamo la porta del vrdp:

VBoxManage modifyvm "ubu_srv_1" --vrde-port 9800

..e lanciamo la macchina virtuale (abbiate cura di mettere la “&” al fondo del comando in modo da poter continuare sulla stessa shell senza chiudere bruscamente il processo della virtual machine):

VBoxHeadless --startvm "ubu_srv_1" &

Quindi aprite il vostro client di desktop remoto preferito e collegatevi all’ip della vostra macchina su cui avete installato virtualbox aggiungendo “:9800”. Il mio indirizzo a cui rispondeva il server rdp era ad esempio 192.168.0.200:9800.
Potete quindi installare normalmente ubuntu server come se foste su una macchina fisica. Finita l’installazione riavviando la macchina partirà il sistema in automatico. Collegatevi e come prima cosa controllate l’ip (meglio assegnarne uno fisso). Prima di poter dire di avere la vm pronta dobbiamo fare in modo che al prossimo lancio non parta più l’immagine di installazione, per cui spegnete la macchina e ritornate sulla shell del server virtualbox:

VBoxManage modifyvm "ubu_srv_1" --boot1 disk

Adesso siete davvero pronti per lanciare la vostra nuova virtual machine. I passi successivi servono per ottimizzare l’utilizzo di ram del vostro server.

Riavviate la macchina fisica che ospita la/le macchina/e virtuale/i e ricollegatevi. Da shell modificate ancora la vm con il seguente comando per non lanciare il server vrdp quando avviate la vm, così da occupare la sola ram indicata per la vostra vm:

VBoxManage modifyvm "ubu_srv_1" --vrde off

Ora potete nuovamente lanciare la vostra macchina virtuale con il comando:

VBoxManage startvm "ubu_srv_1" --type headless &

Per tutti i comandi di VBoxManage fate riferimento all’help:

VBoxManage --help

Per spegnere o mettere in pausa la macchina i comandi sono:

VBoxManage controlvm "ubu_srv_1" poweroff
VBoxManage controlvm "ubu_srv_1" pause

Buon divertimento!

Commenti annidati in wordpress

In questi giorni sono ritornato a lavorare un po’ sul mio amato wordpress.

Oltre a segnalarvi un fantastico restyle grafico del tema di backend per l’amministrazione del blog che potete trovare aggiornando wordpress alla versione 3 oggi voglio parlarvi di come modificare il tema dei commenti.

Questa piccola modifica servirà per visualizzare i commenti annidati, ossia far comparire le risposte ad un commento all’interno del commento stesso, per migliorare la discussione e permettere a chi legge per la prima volta tutti i commenti, chi ha risposto a chi e così via.

WordPress ammette di default una profondità di 5 commenti annidati, ma potete impostarla a piacere tramite il menu “Impostazioni”->”Discussione”.

Se utilizzate uno dei tanti temi scaricati dall’archivio di wordpress verificate solamente che il tema sia aggiornato e di norma dovrebbe già includere questa funzione.

Se invece come me sviluppate spesso temi partendo da zero e partite da un tema semplice e magari non aggiornato alle ultime versioni, dovrete compiere alcuni semplici passi:

  1. Nell’header.php (il file della testata), aggiungete una riga sopra al “wp_head()” con questo codice:
    <?php if( is_singular() ) wp_enqueue_script( ‘comment-reply’ ); ?>
  2. Nel file comments.php dove troverete il tag “ol” con all’interno il tag “li” che ha come classe css “comment” sostituite tutto il blocco con la semplice riga
    <ol class="commentlist">
    <?php wp_list_comments(); ?>
    </ol>
  3. A questo punto non vi resta che editare il vostro css e inserire uno stile personalizzato per i vari livelli di profondità dei commenti, per selezionare il tag “li” relativo al tag “ul” dei commenti inserite in testa al selettore css la classe “.commentlist” e il gioco è fatto!

In pochi e semplici passi avrete così una più chiara visione dei commenti e soprattutto della discussione.

Da notare è che il requisito minimo per poter sfruttare questa funzionalità è quello di avere wordpress 2.7 o versione superiore.

Installare Django 1.3 su Mac OS X 10.7 Lion e XAMPP 1.7.3

Se anche voi come me siete curiosi utilizzatori di mac, in questi giorni sarete sicuramente stati tentati di installare l’ultima versione di OS X, ovvero la major release 10.7 denominata “Lion”.

Se non avete ancora provveduto all’aggiornamento, ma siete in procinto di farlo, vi consiglio quest’ottima guida di macitynet (onde evitare problemi al primo avvio di Lion).

Terminato l’aggiornamento sembrava tutto apparentemente funzionante, fino a quando non ho tentato di avviare il server di sviluppo di django. Non ricordo con precisione l’errore ma il succo era che il driver per la connessione al db non era più funzionante. Ingenuamente ho disinstallato mysql-python(conosciuto anche come mysqldb) credendo fosse sufficiente una reinstallazione…. ripeto: ingenuo. ;-)

Lanciando il comando:

sudo python setup.py build

ottenevo una sbrodolata di errori relativi a librerie gcc. A fiuto ho quindi reinstallato xcode (scaricabile gratuitamente dall’app store) e rilanciato la build di mysql-python… ancora errori, ma quelli precedenti sembravano risolti. Ora le rogne venivano dal mysql_config mancante… Ho scoperto che nella cartella di installazione di mysql-python c’è un file site.cfg che contiene questa famosa variabile mysql_config, la quale deve contenere il path al file mysql_config (file di configurazione di mysql). Per me che uso XAMPP 1.7.3 su mac questo file si trova in “/Applications/XAMPP/xamppfiles/bin”.

Lanciando la build del driver ottengo errori dovuti alla mancanza degli headers di mysql, errore che avevo già riscontrato nell’installazione di Imagick su XAMPP per Mac, vado per cui diretto sul sito di XAMPP 1.7.3, scarico il development package e lo installo.

Sperando nella buona sorte rilancio per l’ennesima volta la build di mysql-python e incappo nell’ennesimo errore. Questa volta sembra che sia dovuto ad una errata versione di XCode, ma leggendo più approfonditamente noto che il problema è dovuto al mancato supporto power-pc (ppc) a partire da XCode 4. Per risolvere questo ennesimo problema si deve editare il famoso mysql_config (in “/Applications/XAMPP/xamppfiles/bin” per chi usa XAMPP) nel seguente modo.

Alla riga 97 sostituite la versione minima di mac osx, io ho modificato da 10.4 a 10.6 (vedete voi), la mia riga ora è così:

ldflags='-L/Applications/XAMPP/xamppfiles/lib -I/Applications/XAMPP/xamppfiles/include -mmacosx-version-min=10.6 '

Alla riga 122 riportate la versione di mac appena modificata e inoltre eliminate la voce -arch ppc, la mia riga ora si presenta così:

cflags="-I$pkgincludedir  -I/Applications/XAMPP/xamppfiles/include -L/Applications/XAMPP/xamppfiles/lib -mmacosx-version-min=10.6 -arch i386 -D_P1003_1B_VISIBLE -DSIGNAL_WITH_VIO_CLOSE -DSIGNALS_DONT_BREAK_READ -DIGNORE_SIGHUP_SIGQUIT  -DDONT_DECLARE_CXA_PURE_VIRTUAL " #note: end space!

A questo punto lanciate la build e per magia arriverà fino al termine senza più errori. Potete quindi installare il pacchetto lanciando il comando:

sudo python setup.py install

A questo punto django sarà tornato alla normalità (a meno che voi utilizzaste le python image library, PIL, per cui dovrete reinstallare anche quelle, ma io non ho riscontrato problemi nel farlo).

Installare Ubuntu Server 10.04 LTS con RAID 10 e LVM

Eccomi qua! Dopo un po’ di tempo con poche “scoperte” interessanti, oggi ritorno con un articolo che riguarda i server.

Ovviamente quando parlo di server, parlo di linux e ancora più nello specifico di Ubuntu.

Ultimamente per andare sul sicuro mi sono abituato ad utilizzare solo più le versioni LTS ossia le Long Term Support, le versioni supportate per 3 anni, decisamente molto più stabili rispetto alle altre.

Quando si installa un server generalmente si ha a che fare con la necessità di mantenere il più possibile al sicuro i dati che vi verranno salvati e per fare ciò è buona norma gestire lo spazio a propria disposizione con il RAID ossiamo un sistema di replica delle informazioni in tempo reale che tenta di ridurre al minimo le possibilità di perdita di dati (ridurre, non eliminare, ne ho le prove ;-) ).

L’installazione di Ubuntu consente di creare un RAID software nel caso in cui il server che stiamo preparando non abbia un sistema di RAID hardware.

Tralasciamo la discussione sulla scelta del RAID, per quello che ho potuto provare sulla mia pelle in genere è sempre meglio un RAID 0 o un RAID 1 o meglio ancora un RAID 1+0 detto anche RAID 10 perchè a differenza dell’alternativo RAID 5 lascia i dati in chiaro e quindi leggibili in qualsiasi momento, anche collegandolo su un’altra macchina (in caso di problemi). Detto ciò, veniamo a come preparare le partizioni per costruire il RAID.

Prendendo l’esempio di 2 dischi da 500 Gb vi conviene creare due partizioni primarie per ciascun disco (scegliete la voce “partizionamento manuale”): una dimensionata il doppio della ram presente sul server, e una con lo spazio rimanente. Ripetete la stessa cosa con le altre due partizioni dell’altro disco. Per ogni partizione alla voce “usare come” dobbiamo ricordarci di impostare “volume per il raid”. Fatto ciò possiamo terminare il partizionamento e configurare gli array raid tramite l’apposito menu, scegliendo il raid desiderato e settando quanti dischi usare per il raid (2) e quanti dischi di spare(0).

Come detto dobbiamo configurare due array, uno per la swap e uno per il sistema vero e proprio. Per il primo array scegliamo i due volumi a cui abbiamo assegnato il doppio della dimensione della ram, confermiamo e passiamo alla configurazione del secondo array con i restanti due volumi.

Finita la configurazione dei due array del raid possiamo terminare l’operazione e scrivere le modifiche.

Quando apparirà nuovamente la schermata con le tabelle delle partizioni potremo notare che sono state aggiunte due voci all’elenco, ossia quelle corrispondenti ai due arrays. A questo punto possiamo creare due partizioni (una per array) e impostare la voce “usare come” su “volume per LVM”.

L’LVM è un gestore dei volumi logici, ossia consente di creare dei volumi “estendibili” in qualsiasi momento. Infatti smontando i volumi si possono aumentare le loro dimensioni senza dover formattare e senza subire perdite di dati, e addiritture si possono raggruppare in un unico volume più dischi (anche aggiunti in un secondo momento). Un po’ quello che si può fare tramite l’ormai conosciutissimo GParted in Ubuntu desktop.

Tornando all’installazione del nostro ubuntu server, una volta impostate le nostre partizioni come volumi per LVM possiamo procedere alla creazione dei due volumi logici, come già detto uno per lo swap e uno per il sistema. Una volta confermata la creazione dei due volumi logici (dovrete assegnare un nome ai volumi da creare, ad esempio “swap” e “srv”) nella tabelle delle partizioni troveremo altre due voci, rappresentati i due nuovi volumi appena creati.

A questo punto possiamo procedere alla creazione delle partizioni da far usare all’installazione di Ubuntu: una da impostare come “volume swap” e l’altra da impostare con ext4 (o ext3 per i più tradizionalisti :-P ). Ovviamente la partizione formattata con ext4 dovrà avere come punto di mount “/” (root). Confermate queste modifiche l’installazione procederà a gonfie vele, e in pochi minuti il vostro server sarà pronto per l’uso! :-)

Calibrare la batteria di un Macbook Pro e non solo…

E’ passato quasi un anno da quando ho abbandonato il mondo dei pc per passare a mac. Ma non voglio stressarvi su quanto mi trovi bene in questo mondo rispetto all’altro, per il momento siete salvi ;-). Voglio invece raccontarvi di una piccola scoperta fatta.

Quando ho avuto tra le mani il mio Macbook Pro, una delle prime cose su cui mi sono documentato è stato il “come usare al meglio la batteria”. Viste le passate esperienze da ignorante su questo argomento, e dato che il mio vecchio pc era arrivato ad avere una quindicina di minuti di autonomia rispetto alle due ore e mezza iniziali, desideravo non ripetere l’esperienza negativa. Dopo poche ricerche sono finito su questa pagina ufficiale di apple.

Apple consiglia di usare a piacere il proprio mac senza preoccuparsi troppo della batteria, seguendo solo alcune semplici regole. L’elemento essenziale delle batterie al litio è quello di far “muovere” gli elettroni che stanno all’interno delle batterie, è sconsigliabile quindi lavorare sempre collegati alla rete elettrica. L’uso ottimale è quello di un pendolare che usa la batteria del suo mac sul treno mentre va a lavoro e poi una volta arrivato in ufficio lo collega alla rete, per poi fare la stessa cosa nel viaggio di ritorno.

Fortunatamente non tutti prendiamo il treno, e non mi sembra cosa buona e giusta prendere il treno solo per ottimizzare l’uso della propria batteria, ma ricordatevi di farla scaricare e ricaricare di tanto in tanto.

Oltre a ciò Apple consiglia di calibrare la batteria una volta ogni due mesi (o una volta al mese ancora meglio). La calibrazione non richiede nulla di troppo faticoso ma soltanto alcuni piccoli accorgimenti. Riporto di seguito i passi da seguire per effettuare la calibrazione della batteria del vostro mac (la pagina ufficiale è questa):

  1. Collegare l’alimentatore al proprio mac e caricarlo completamente fino a quando la luce del connettore non diventa verde o quando l’icona della batteria nella barra in alto non segnala la carica completata.
  2. Lasciare l’alimentatore collegato al mac per due ore o più. Durante questa fase potete tranquillamente continuare ad usare il vostro mac.
  3. Passate almeno le due ore, scollegare il cavo dell’alimentatore con il mac acceso e iniziare (o continuare) ad usarlo per scaricare la batteria.
  4. Portare la carica della batteria al minimo, salvare i lavori e usare il mac fino a quando non va in stato di stop autonomamente.
  5. A questo punto lasciare spento il mac per almeno 5 ore
  6. Passate le 5 ore, ricollegare il mac all’alimentatore e caricarlo fino a raggiungere la carica completa (è possibile usare il mac in questa fase).

Come vi dicevo ho fatto una scoperta: sul nuovo pc che uso per lavoro ho installato Ubuntu 10.04, il quale ha l’applicazione di gestione della batteria che segnala la carica di fabbrica della batteria in uso e l’ultima carica raggiunta. Vedendo che dopo alcune scariche e ricariche l’ultima carica raggiunta si allontanava dalla carica di fabbrica ho provato a seguire la stessa procedura che uso per calibrare la batteria del mac e…. funziona! ;-). Dopo aver calibrato la batteria, Ubuntu mi segnalava l’ultima carica raggiunta identica alla carica di fabbrica.

In definitiva credo che tutti i notebook di ultima generazione (ovvero con batteria al litio) possano seguire questa procedura.

Grazie ad Apple per queste preziose indicazioni per mantenere al meglio le batterie dei nostri portatili! ;-)

Installare tomcat 6 e postgresql 8.4 su ubuntu server 10.04

L’ambiente più familiare (lato server) per realizzare applicazioni web su linux è senza ombra di dubbio un server LAMP (Linux Apache MySQL PHP).

Ormai lo si riesce ad installare senza grosse difficoltà anche in ambiente linux, grazie (ancora una volta) ad ubuntu che mette a disposizione e ci configura tutti i pacchetti necessari per avere un ambiente completamente funzionante.

A volte risulta però necessario uscire dal seminato, cambiando magari DBMS o linguaggio di programmazione. Vuoi perchè si vuole avere un db più simile ad Oracle o vuoi perchè si preferisce un linguaggio più strutturato o più familiare ai programmatori.

Mi è successo alcuni giorni fa di provare a configurare sul mio server di casa, un ubuntu server 10.04 LTS, un gestionale web scritto in java compatibile con sql server o postgresql. Visto che, come saprà chi mi conosce, non amo molto le tecnologie microsoft e che non credo si riesca ad installare sql server su linux, ho deciso di buttarmi su postgresql ;-)…

Dovremmo quindi installare tomcat per avere un server web java e postgresql per il lato database.

Per prima cosa, assicuriamoci di avere il java development kit di Sun installato:

sudo apt-get install sun-java6-jdk

Ora possiamo procedere con l’installazione del server web tomcat:

sudo apt-get install tomcat6
sudo apt-get install tomcat6-admin

Una volta installati questi pacchetti il nostro server web sarà pronto per essere utilizzato e amministrato, potete verificarne il funzionamento digitanto da browser http://ip_server:8080/, dove ipserver sarà l’indirizzo ip della macchina su cui avete installato tomcat.

Per poter entrare nella sezione di amministrazione delle applicazioni installate in tomcat e verificare lo stato del server, si dovrà creare un utente e fornirgli i privilegi di amministrazione. Per fare ciò editate il file /etc/tomcat6/tomcat-users.xml inserendo le seguenti linee:

<role rolename="admin"/>
<role rolename="manager"/>
<user username="admin" password="admin" roles="admin,manager"/>

Tomcat su linux usa di default le openjdk ovvero le jdk java open source e non quelle ufficiali sun, perciò potreste incorrere in problemi di incompatibilità se installate software non testato su questa piattaforma, per modificare le jdk usate editate il file /etc/default/tomcat6/ e alla voce JAVA_HOME sostituite la linea con questa:

JAVA_HOME=/usr/lib/jvm/java-6-sun

Bene, ora che il server è installato e configurato possiamo passare all’installazione di postgresql:

sudo apt-get install postgresql

Ora che postgresql è installato configuriamo gli indirizzi ip sui quali il db server sarà in ascolto. Potrebbe non essere necessario fare questa configurazione se non desiderate gestire postgresql dall’esterno, ma pgadmin è un tool di gestione per postgresql davvero comodo. Editate quindi il file /etc/postgresql/8.4/main/postgresql.conf così:

listen_addresses = 'localhost,<em>ip_server</em>'

Dove ip_server sarà sempre l’ip della macchina su cui avete installato postgre.

Ora inseriamo la password per l’utente default postgres:

sudo -u postgres psql template1

Si aprirà la shell di postgre e dovremo eseguire la query:

ALTER USER postgres with encrypted password 'password';

Fatto ciò possiamo editare il file dei permessi di postgre /etc/postgresql/8.4/main/pg_hba.conf:

local   all   all   md5
host   all   all   192.168.0.0/24   md5

A questo punto possiamo riavviare sia tomcat sia postgre:

sudo /etc/init.d/tomcat6 restart
sudo /etc/init.d/postgresql-8.4 restart

…e andare a posizionare le nostre applicazioni in /var/lib/tomcat6/webapps/ e gestire i database da shell o tramite pgadmin ;-)

Preparare un web server per django su ubuntu server 10.04

Poco tempo fa ho scoperto il favoloso mondo di Django, un web framework che consente di scrivere meno codice e creare applicazioni python davvero molto efficienti.

Oltre ad essere un framework che implementa l’MVC(Model View Controller), la caratteristica che mi ha attratto maggiormente è una fantastica funzionalità di ORM(Object Relational Mapping).. cosa significa? In poche parole nel file che implementa il “Model” (models.py) dovrete dichiarare gli oggetti che verranno trasformati in tabelle del vostro database, al resto penserà django. Infatti una volta collegato un db e scritte le classi del modello, con la funzione syncdb verranno create le tabelle residenti sul db. Vi rimando però al tutorial ufficiale per capire davvero qualcosa in più su questo fantastico framework…

In questo post vi farò vedere i pochi e semplici passi per configurare un web server adatto ad ospitare un’applicazione django. Ovviamente il server linux girerà grazie ad ubuntu server ed in particolare nella versione LTS(long term support) 10.04. Salterò ovviamente i passi dell’installazione vera e propria del sistema operativo (anche perchè ormai è a prova di win-user :-P ).

Partendo da un sistema pulito, su cui non è stato installato nessun componente, dovremo per prima cosa assicurarci che il sistema sia aggiornato:

sudo apt-get update
sudo apt-get dist-upgrade
sudo apt-get upgrade

Fatto ciò possiamo procedere con l’installazione dei componenti necessari a mettere in piedi un server web, il che equivale ovviamente ad installare il buon vecchio Apache:

sudo apt-get install lamp-server^

In questo modo installeremo tutti i pacchetti per avere un server LAMP ovvero con apache come detto, e con mysql per la parte di database (verrà installato anche php5 per poter utilizzare phpmyadmin, l’interfaccia per la gestione da web di mysql)

Attesi i dovuti tempi per lo scaricamento, l’installazione e la configurazione dei vari pacchetti (vi verrà chiesta la password per mysql) dovreste avere il vostro server web funzionante (potete testarlo collegandovi da un qualsiasi browser nella rete all’indirizzo ip del server es: http://192.168.0.1 ).

Bene, ora manca un ultimo componente per avere il server pronto: il mod_wsgi ovvero il modulo apache per l’interpretazione del codice python:

sudo apt-get install libapache2-mod-wsgi

Ora non ci resta che installare il driver per fare comunicare python e mysql, che come detto sarà per comodità il nostro dbms:

sudo apt-get install python-mysqldb

Ora possiamo procedere al download e installazione del framework dal sito ufficiale di django(vi risparmio il “wget”, mi sembrava troppo da nerd, ma si può fare ;-) ). Trasferite il tar.gz sul server se non è già lì, e scompattatelo (tar -xvzf nomefile.tar.gz per i newbie). Ora entrando nella cartella che avete ottenuto dalla scompattazione potete installare django:

sudo python setup.py install

Vi consiglio spassionatamente di installare la release ufficiale di django e non quella dagli archivi ubuntu per un puro fatto di aggiornamento della versione, infatti sul canale ufficiale sarete sicuri di avere l’ultima stable-release mentre ubuntu è sempre più indietro in queste cose…

Bene adesso abbiamo tutto ciò che ci serve(r) (battuta di bassissimo umorismo, non ci fate caso, è l’età :-P ).

Procediamo con la creazione del file python che darà le direttive al mod_wsgi sui percorsi della nostra applicazione, nella cartella del nostro progetto, creiamo il file django.wsgi:

vim /home/user/py-srv/applicazione1/django.wsgi

Ipotizzando che la nostra applicazione risieda in /home/user/py-srv/applicazione1 …

Il file dovrà contenere il seguente codice:

import os
import sys

sys.path.append('/home/user/py-srv/applicazione1')

os.environ['PYTHON_EGG_CACHE'] = '/home/user/py-srv/.python-egg'
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'

import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()

Ora dobbiamo solamente dire ad apache quale sarà la cartella della nostra applicazione. Per fare ciò editiamo il file default nella cartella sites-available di apache (prima però facciamo una copia del file per sicurezza ;-) ) :

sudo cp /etc/apache2/sites-available/default /etc/apache2/sites-available/default.old
sudo vim /etc/apache2/sites-available/default

Il file dovrà contenere le seguenti configurazioni:

<VirtualHost *:80>
   DocumentRoot /home/user/py-srv/applicazione1/public_html

   WSGIScriptAlias / /home/user/py-srv/applicazione1/django.wsgi
   <Directory /home/user/py-srv/applicazione1>
      Order allow,deny
      Allow from all
   </Directory>

   Alias /favicon.ico /home/user/py-srv/applicazione1/public_html/favicon.ico
   Alias /images /home/user/py-srv/applicazione1/public_html/images
   Alias /static /home/user/py-srv/applicazione1/public_html/static

   ErrorLog /home/user/py-srv/applicazione1/logs/error.log
   CustomLog /home/user/py-srv/applicazione1/logs/access.log combined
</VirtualHost>

Come potete immaginare la cartella “public_html” sarà quella che conterrà i file html pubblici, ovvero i file del template della vostra applicazione.

Bene, se avete fatto tutto nel modo giusto, vi basterà collegarvi all’indirizzo ip che avete già usato prima per testare apache, e vedrete come per magia che funzionerà tutto!

(non funziona? non fate come me che avevo lasciato il vecchio path nel file settings.py, e ci ho perso mezz’ora per accorgermene :-P )

Buon divertimento!

Creare un web service con SOAP e PHP

Ai tempi dell’università, nel corso di programmazione in rete tenuto dal Prof. Matteo Baldoni, avevamo realizzato un ottimo progetto in Java di agenti che interagivano tra di loro.
Era anche questo una specie di servizio web anche se era realizzato con RMI ovvero Remote Method Invocation, ossia una funzione di java che consente di invocare metodi di oggetti remoti da altre java virtual machine.

Oggi visto che sono ancora a casa per l’influenza, ho deciso di documentarmi sui web services in php, dato che probabilmente dovrò realizzare un progetto in cui potrebbero tornarmi utili.

Seguendo l’ottima guida “PHP 6, Guida per lo sviluppatore” di Lecky-Thompson, Novicki e Myer (ve la consiglio vivamente se siete interessati all’argomento, è davvero ottima), ho deciso di riprodurre l’esempio di un client-server SOAP(Simple Object Access Protocol). Innanzitutto SOAP è un protocollo per lo scambio di messaggi tra agenti software, ossia un client tramite soap può richiamare funzioni di un server inviando e ricevendo parametri. E fin qui nulla di strano mi direte voi… Infatti, la cosa interessante deve ancora arrivare! La peculiarità di scrivere software implementando SOAP è che client e server possono essere scritti in linguaggi diversi, essendo quest’ultimo appunto un protocollo e non una componente software. Tutti i linguaggi più comuni hanno delle classi che implementano SOAP, sia lato server sia lato client. Diventa così facile capire che una volta scritto un server SOAP che implementa alcune funzioni, possono esserci N client che sfruttano queste funzioni per leggere dati comuni o interagire con applicazioni sul web.

Ecco allora che ci spieghiamo come sia possibile che tutte le applicazioni web più famose, da quelle di google, a facebook fino a twitter, mettano a disposizione metodi per interagire dall’esterno con i loro servizi (le famose API, Application Programming Interface).

Come vi dicevo ho messo in pratica l’esempio che ho trovato sulla guida di PHP, potete raggiungerla a questo indirizzo. L’esempio non fa altro che realizzare un server che ha un metodo che prende in input un nome e restituisce un saluto, comprensivo del nome inviato. Il client ovviamente preso in input il nome invia la richiesta al server e stampa il saluto ricevuto. Nulla di complicato, ma si riescono ad intuire le potenzialità di questo protocollo.

I due script in php come vedrete fra poco, sono molto semplici, e non richiedono più di una decina di righe di codice ciascuno, la parte fondamentale di questo esempio è però il file wsdl, ossia il file xml di dichiarazione dei metodi messi a disposizione dal server. Questo file non è indispensabile ma è utile a chi implementa i client per sfruttare tutte le funzioni messe a disposizione da SOAP.

Come vi dicevo dal lato server il codice php è semplice:

function sayHello($name){
    $salutation="Ciao ".$name.", sarai lieto di sapere che sto funzionando!";
    return $salutation;
}
$server= new SoapServer("test.wsdl");
$server->addFunction("sayHello");
$server->handle();

Il file xml per le dichiarazioni è invece un po’ più complesso ma con un po’ di attenzione non sarà difficile comprenderne il significato:

<?xml version="1.0" encoding="UTF-8" ?>
<definitions name="test"
targetNamespace="http://URL_CARTELLA_SERVER_SOAP"
xmlns:tns="http://URL_CARTELLA_SERVER_SOAP"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns="http://schemas.xmlsoap.org/wsdl/">

    <message name="sayHelloRequest">
        <part name="name" type="xsd:string"/>
    </message>
    <message name="sayHelloResponse">
        <part name="salutation" type="xsd:string"/>
    </message>

    <portType name="sayHelloPortType">
        <operation name="sayHello">
            <input message="tns:sayHelloRequest" />
            <output message="tns:sayHelloResponse" />
        </operation>
    </portType>

    <binding name="sayHelloBinding" type="tns:sayHelloPortType">
        <soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" />
        <operation name="sayHello">
            <soap:operation soapAction="" />

            <input>
                <soap:body use="encoded" namespace="" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
            </input>
            <output>
                <soap:body use="encoded" namespace="" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
            </output>
        </operation>
    </binding>
    <documentation>UNA VOSTRA DESCRIZIONE DEL SERVIZIO</documentation>
    <service name="sayHelloService">
        <port name="sayHelloPort" binding="sayHelloBinding">
            <soap:address location="http://URL_SCRIPT_PHP_SERVER_SOAP" />
        </port>
    </service>
</definitions>

Fatto ciò, non ci resta che scrivere il codice per il client (tralascio il banale form html, ma metto a disposizione lo zip con tutto dentro):

$wsdl_url="http://URL_AL_DEL_FILE_WSDL";
if(isset($_POST['name'])){
    if($_POST['name']!=null){
        $client=new SoapClient($wsdl_url);
        print_r($client->sayHello(htmlentities($_POST['name'])));
    }
}

La cosa fondamentale per poter utilizzare SOAP è che il vostro php abbia l’estensione php_soap abilitata, ma se ho capito bene, da php6 viene inclusa di default tra le funzioni del core di php. Tra l’altro essendo inclusa nelle funzioni default di php è scritta in C per cui molto più veloce rispetto a scrivere codice php, di conseguenza, in queste applicazioni l’unico collo di bottiglia potrebbe essere la lentezza della linea o i tempi di ping/risposta di client e/o server.

Se siete pigri e volete testare il codice senza dovervi sbattere, eccolo qui, pronto per voi già impacchettato ;-)

Prossimamente testerò anche REST un altro metodo per realizzare web service con meno rogne, non serve infatti nessun file di dichiarazione, ma anche meno rigido e controllato.