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.

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).

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! :-)

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! ;-)

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 ;-)

Ho lavorato qualche giorno(ma soprattutto qualche notte :-P) per realizzare il nuovo tema wordpress, cercando di seguire le linee guida dettate dal mio amico architetto Ermal Brahimaj.

Discutendo insieme di cosa doveva avere il mio blog, e di come doveva essere realizzato, mi ha dato alcune brillanti idee, analizzando il mio sito sotto il punto di vista di un utente che vede per la prima volta questo spazio. Il design è minimal (spero piacerà anche a @marcoviti ;-) ) e utilizza solamente una scala di grigi. Ho eliminato tutto il superfluo, in modo che il lettore si possa concentrare solamente sul contenuto, il vero “succo” di questo sito. Proprio per accentuare questo concetto, (se provate a spostare il mouse sul testo dell’articolo ne avrete la prova) ho utilizzato jQuery per far “scomparire” il superfluo, ovvero il banner il menu e la ricer ca, così che il lettore non abbia distrazioni. Inoltre non ci sono linee che delimitino lo spazio del sito, proprio dare la sensazione di libertà, di respiro.

Spero piaccia anche a voi questo restyling, in ogni caso ringrazio davvero il mio amico Ermal per le idee che mi ha dato e vi invito, se non lo avete ancora fatto, a visitare il suo sito brahimaj.com e la sezione progetti per dare un’occhiata ai suoi lavori!

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!

Un gruppo americano, fino ad oggi per me assolutamente sconosciuto (ma sono davvero una capra in fatto di musica, magari sono davvero bravi), gli Atomic Tom sono stati derubati di tutti i loro strumenti musicali.

Chiunque sarebbe andato alla polizia e avrebbe atteso il ritrovamento degli strumenti o ne avrebbe ricomprati di nuovi e invece….. Hanno preso i loro iPhone (con le dovute app, acquistate dall’Apple App Store), sono saliti su un vagone della metro di New York city e hanno tenuto un mini concerto per i fortunati viaggiatori.

Vi lascio al video davvero divertente e singolare ;)

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.

Da oggi potete condividere gli articoli del blog che vi piacciono su facebook o buzz, cliccando sulle icone nel riquadro grigio al fondo dei post.

Per quanto riguarda facebook, l’inserimento del plugin prevede l’utilizzo delle Facebook javascript SDK. Per prima cosa si deve registrare il proprio sito come applicazione, in modo da ottenere un “application id”. Una volta fatto ciò potete aggiungere in fondo alla vostra pagina il codice javascript per caricare le sdk:

<div id="fb-root"></div>
<script>
  window.fbAsyncInit = function() {
    FB.init({appId: 'your app id', status: true, cookie: true,
             xfbml: true});
  };
  (function() {
    var e = document.createElement('script'); e.async = true;
    e.src = document.location.protocol +
      '//connect.facebook.net/en_US/all.js';
    document.getElementById('fb-root').appendChild(e);
  }());
</script>

Ora potete aggiungere il tag FBML che caricherà il pulsante “mi piace”:

<fb:like href="URL da segnalare" layout="button_count"></fb:like>

Potete personalizzare il tipo di pulsante tramite il tag “layout”:

• “standard” per avere il pulsante con la frase a fianco
• “button_count” per avere il pulsante con il contatore dei “like”
• “box_count” per avere il pulsante e il contatore su due righe diverse

e tramite il tag “colorscheme”:

• “light” per lo schema di colori default
• “dark” per lo schema di colori grigio scuro

Nel tag href dovete inserire l’url che volete sia segnalata quando qualcuno clicca sul pulsante.

Per quanto riguarda Google buzz invece, non è necessario registrare nessuna applicazione, si dovrà solamente includere il codice javascript per le Google Buzz SDK in fondo alla pagina:

<script type="text/javascript" src="http://www.google.com/buzz/api/button.js"></script>

e il codice del pulsante per condividere il link

<a href="http://www.google.com/buzz/post"
  class="google-buzz-button" title="Google Buzz"
  data-message="Here’s Buzz!"
  data-url="http://www.google.com/buzz"
  data-locale="it"
  data-button-style="normal-count"></a>

È anche possibile personalizzare il pulsante modificando il tag “data-url” inserendo l’url alla pagina che si vuole segnalare, e il tag “data-button-style” con le seguenti voci:

• normal-count

• small-count
• normal-button
• small-button
• link

Come potete notare al nostro arrivo, c’erano già i mac genius che distribuivano caffè e brioches per tutte le persone in coda.

Alle 7,45 avevamo già una cinquantina di persone davanti a noi…

Qualche minuto prima dell’apertura i dipendenti del negozio, sono usciti per fare il “giro d’onore” lungo la coda. Cantando cori da stadio e urlando schiacciavano “un cinque” alle persone in fila…

Alle 10,00 in punto, le porte si sono aperte e i genius hanno accolto i primi della fila facendo la ola e distribuendo ad ognuno la maglietta celebrativa dell’evento (nera con la mela bianca e “Le Gru” scritto a fianco)

E così che in meno di 10 minuti mi son ritrovato nel parcheggio del centro commerciale. Dopo un attimo di “smarrimento” ho trovato la retta via e ho notato un gruppetto di persone che scattavano foto in lontananza… Camminando in quella direzione mi son trovato di fronte a ciò che cercavo.

Come tutti gli Apple Store visti in foto, anche quello torinese è identico agli altri. Ampie vetrate con la mela bianca e luminosa piazzata in alto sulla vetrata centrale. Sulla destra due iPhone 4 giganti con al posto dello schermo due monitor che proiettano delle demo di iOs 4. Lo store è davvero molto grande (me lo aspettavo più piccolo e non ho visto gli altri dal vivo), ci sono diverse file degli ormai noti banconi in legno chiaro, con sopra tutti i vari dispositivi made in Cupertino.

Sono arrivato lì intorno alle 18,00 e il negozio era davvero molto affollato al suo interno nonostante l’apertura sia domani. Se gli occhi non mi hanno ingannato ho contato almeno una trentina di dipendenti (in rigorosa t-shirt blu) e credo che tutti i visitatori fossero addetti della carta stampata e da quanto ho visto venivano fatti entrare da un’entrata posteriore.

Per ora vi lascio alle prime immagini che ho scattato davanti allo store, per tutto il resto dovrete attendere domani, quando sarò di ritorno dalla gita torinese insieme al mio iSocio Bove sperando di essere riusciti ad accaparrarci la tanto agognata maglietta! :)

Ps: Se non ci credete, credeteci seguendo il link http://www.apple.com/it/retail/legru/

Bentornati a tutti dalle vacanze, oggi ritorno con un articolo dedicato ai macachi come me.

Avete bisogno di tener traccia dei vostri appuntamenti, eventi, ricorrenze? Be’ esistono i calendari elettronici, oppure le agendine elettroniche, oppure le agende cartacee…. oppure Google Calendar

Ieri sera, parlavo con Denny (che devo ringraziare per l’input di questa mattina, SENZA di lui non sarei riuscito a scoprire questa sciccheria… :-P ) e mi ha detto che usava un’estensione di thunderbird per tenere traccia di tutti gli appuntamenti, eventi ecc… Siccome anche io, a lavoro, uso la stessa estensione per thunderbird, gli ho spiegato secondo me cosa non funzionava di quel sistema e cioè che gli eventi creati rimanevano sul pc e non c’era nessun metodo per ricevere avvisi via mail o meglio ancora sms. Avevo infatti provato Google Calendar e notato che aveva la splendida funzionalità di impostare gli avvisi via sms.

Stamattina perciò dopo esserci ritrovati su gtalk abbiamo cercato qualche sistema per sincronizzare i calendari software con il servizio di google, scoprendo che quasi tutti i calendari supportando lo standard calDav.

Vi spiego ora come sincronizzare iCal, il software per il calendario su mac, con Google Calendar:

• nella barra dei menu, selezionare iCal->Preferenze
• selezionare il tab “Account” e poi premere “+” per aggiungere un nuovo account.
• come “Tipo account” dovreste già avere “Google”, se non ci fosse selezionate la voce “calDav”
• a questo punto vi basterà inserire l’indirizzo del server google (google.com), la vostra mail completa che usate per accedere ai servizi di google e la relativa password

Ora quando creerete un nuovo evento su iCal, questo verrà automaticamente sincronizzato on-line.

La stessa cosa può essere fatta su iPhone:

• per prima cosa collegatevi all’indirizzo https://www.google.com/calendar/iphoneselect e confermate di voler usare il calendario di google dal vostro iPhone.
• ora andate nelle impostazioni e selezionate la voce “Mail, contatti, calendari”
• selezionate la voce “aggiungi account” e scegliete “altro”
• qui troverete la voce “aggiungi account calDav”
• inserite di nuovo le informazioni relative al vostro login e al server google (google.com)

Ora avrete iCal sul vostro mac e sul vostro iPhone che salverà le informazioni su google Calendar e in qualsiasi momento potrete accedere ai vostri appuntamenti, eventi e ricorrenze

Ancora grazie a Denny per il supporto, nonostante sia dichiaratamente anti-apple :-P

Diciamo che prima di intraprendere il lavoro ho perso qualche minuto a cercare la documentazione necessaria, che mi avrebbe accompagnato durante il cammino.

Inizialmente avevo preso un pc davvero modesto (con processore AMD Duron, qualcosa di simile al Sempron ma un po’ più vecchio ;-) ) con 40 ghiga di disco e 512 Mb di ram SO DIMM, credendo di usarlo come test per la macchina vera. Ovviamente ho installato Ubuntu server come sistema operativo, scaricando l’ultima versione (10.04) siccome è un LTS. Nell’installazione del S.O. non c’è stato alcun inghippo, oramai queste ultime versioni sono una pacchia, filano dritte dritte in pochi minuti verso il traguardo ;-).

Una volta installato Ubuntu ho seguito il wiki in inglese per la corretta installazione di open vpn. Come prima passo, la guida consiglia di configurare un bridge sulla scheda ethernet per consentire al segmento LAN di essere connesso al segmento WAN, consentendo (se si vuole) di filtrare i pacchetti che li attraversano con un firewall. Per fare ciò basta installare un pacchetto chiamato bridge-utils con il comando:

sudo apt-get install bridge-utils

Fatto ciò si deve editare il file di configurazione della rete con il comando:

sudo vim /etc/network/interfaces

modificarlo come segue:

auto lo
iface lo inet loopback

auto br0
iface br0 inet static
        address 192.168.0.10
        network 192.168.0.0
        netmask 255.255.255.0
        broadcast 192.168.0.255
        gateway 192.168.0.1
        bridge_ports eth0
        bridge_fd 9
        bridge_hello 2
        bridge_maxage 12
        bridge_stp off

Così facendo si assegna il bridge all’interfaccia eth0 con l’ip 192.168.0.10.

Adesso potete riavviare il servizio networking:

sudo /etc/init.d/networking restart

(per evitare di dover digitare sempre il comando sudo davanti ad ogni comando vi consiglio di digitare sudo su una volta per tutte)

Ora possiamo passare all’installazione vera e propria di OpenVPN:

apt-get install openvpn

Finita l’installazione del pacchetto creiamo una cartella che conterrà i programmi per generare le chiavi e le chiavi stesse:

cp -r /usr/share/doc/openvpn/examples/easy-rsa/2.0 /etc/openvpn/
mv /etc/openvpn/2.0 /etc/openvpn/easy-rsa

Dopodichè editiamo il file vars in modo da modificare le seguenti linee con le informazioni che ci riguardano:

export KEY_COUNTRY="US"
export KEY_PROVINCE="NC"
export KEY_CITY="Winston-Salem"
export KEY_ORG="Example Company"
export KEY_EMAIL="steve@example.com"

Salvate il file e chiudetelo. Accertandovi di essere loggati come utente di root, iniziate la procedura di generazione delle chiavi:

cd /etc/openvpn/easy-rsa/
source ./vars
./clean-all
./build-dh
./pkitool --initca
./pkitool --server server
cd keys
openvpn --genkey --secret ta.key
cp server.crt server.key ca.crt dh1024.pem ta.key /etc/openvpn/

Ora che abbiamo generato le chiavi e i certificati per il server procediamo a generare quelli per il client (basterà ripetere la prossima procedura modificando l’identificativo del client per generare altre chiavi/certificati):

cd /etc/openvpn/easy-rsa/
source vars
./pkitool client1

Copiate ora sul client i file:

• /etc/openvpn/ca.crt
• /etc/openvpn/easy-rsa/keys/client1.crt
• /etc/openvpn/easy-rsa/keys/client1.key
• /etc/openvpn/ta.key

Ora non ci resta che editare i file di configurazione per server e client (partiamo da una configurazione di esempio):

cp /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz /etc/openvpn/
gzip -d /etc/openvpn/server.conf.gz
vim /etc/openvpn/server.conf

Accertatevi di correggere le seguenti linee con i vostri dati:

local 192.168.0.10
dev tap0
script-security 3
up "/etc/openvpn/up.sh br0"
down "/etc/openvpn/down.sh br0"
proto tcp
;server 10.8.0.0 255.255.255.0
server-bridge 192.168.0.10 255.255.255.0 192.168.0.100 192.168.0.110
push "route 192.168.0.1 255.255.255.0"
tls-auth ta.key 0 # This file is secret
user nobody
group nogroup
cipher AES-256-CBC

La voce local sarà quella corrispondente all’indirizzo del vostro bridge, come la prima voce accanto a server-bridge. La seconda voce di server-bridge sarà la subnet mask mentre la terza e la quarta sarà il range di ip che openvpn assegnerà ai client che si connetteranno alla rete.
Il comando push “route… servirà per creare una rotta sugli indirizzi della LAN.
Fatto ciò, creiamo i due script per l’avvio e la chiusura dell’interfaccia virtuale (la tap0 che vedete nel file di configurazione). Creiamo il file up.sh come segue:

vim /etc/openvpn/up.sh

#!/bin/sh
BR=$1
DEV=$2
MTU=$3
/sbin/ifconfig $DEV mtu $MTU promisc up
/usr/sbin/brctl addif $BR $DEV

e il file down.sh così:

vim /etc/openvpn/down.sh

#!/bin/sh
BR=$1
DEV=$2
/usr/sbin/brctl delif $BR $DEV
/sbin/ifconfig $DEV down

Rendiamoli eseguibili:

chmod 755 /etc/openvpn/down.sh
chmod 755 /etc/openvpn/up.sh

Ora che il server è correttamente configurato, possiamo dare una riavviata al servizion openvpn:

/etc/init.d/openvpn/restart

Adesso passiamo al file di configurazione del client:

sudo cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf /etc/openvpn

Il quale dovrà contenere:

dev tap
proto tcp
remote 192.168.0.10 1194
cert client1.crt
key client1.key
tls-auth ta.key 1
cipher AES-256-CBC

Ora copiate nella cartella di configurazione del client il file appena editato (chiamatelo client1.conf o client1.ovpn). Ovviamente si presuppone che i file delle chiavi e dei certificati siano nella stessa cartella di quest’ultimo file (sul client). Riavviate anche qui openvpn e il gioco è quasi fatto. Dico quasi perchè per potervi connettere al server dall’esterno dovrete dire al vostro router di aprirvi la porta 1194 e reindirizzare il traffico proveniente dall’esterno verso l’ip 192.168.0.10 (quello del bridge).

Ora siete davvero pronti per collegarvi dall’esterno alla vostra LAN (così com’è stato configurato openvpn non è possibile accedere da dentro la LAN alla vpn appena creata).

Spero di non aver dimenticato niente! ;-)

Che ve ne pare?

Nel disegnare le interfacce, uno degli oggetti che sto trovando sempre più utile, è la jTable, nient’altro che una semplice tabella (la vecchia DataGrid di visual basic). Inizialmente avevo trovato un po’ ostico capire come funzionasse, nonostante ci fossero parecchi esempi che danno molti consigli su come usarle. Una delle pagine di esempi più complete è questa sul sito oracle.

Voglio però spendere qualche riga per spiegare come poter facilmente caricare una jTable leggendo i dati da un resultset o da un elenco qualsiasi.

Penso che il concetto più semplice per utilizzare al meglio le jTable sia implementare una List<T> (dove T può essere un array di Object o di String o una vostra classe personale, fate voi) con una ArrayList o una LinkedList. Questa lista terrà aggiornata la jTable.

Personalmente creo sempre un metodo che chiamo “refreshTable” che legge i dati dalla lista e li inserisce nella tabella. Il metodo non farà altro che usare un iteratore per scorrere la lista e creare una matrice di Object da passare alla nostra jTable per riempirla.

        //Creo array di intestazioni
        String [] headers=this.getTableHeaders();
        //Creo matrice di dati
        Object[][] data=new Object[this.lista.size()][headers.length];
        int i=0;
        for(Iterator<String[]> it=lista.iterator();it.hasNext();){
            String[] tmp=it.next();
            for(int j=0;j<tmp.length;j++){
                data[i][j]=tmp[j];
            }
            i++;
        }
        //Setto dati e intestazioni della tabella
        this.myJTable.setModel(new javax.swing.table.DefaultTableModel(data, headers){@Override public boolean isCellEditable(int rowIndex, int mColIndex) { return false; }});
        //Setto larghezza colonne
        this.setTableCellsSize(this.myJTable);
        //Imposto allinamento delle celle al centro
        DefaultTableCellRenderer renderer=new DefaultTableCellRenderer();
        renderer.setHorizontalAlignment(DefaultTableCellRenderer.CENTER);
        this.myJTable.setDefaultRenderer(this.myJTable.getColumnClass(0), renderer);
        this.myJTable.updateUI();

Così facendo abbia riempito la nostra jTable. Il metodo che fa ciò è il setModel(), al quale io passo sempre una matrice di Object che contiene i dati veri e propri e un array di String che contiene le intestazioni della tabella (che leggo dal mio metodo this.getTableHeaders() ). Oltre a questo ho creato un metodo (this.setTableCellsSize() ) che imposta la larghezza delle varie colonne della tabella:

        int prefWidth=(this.getWidth()/2)/(this.getHeadersTable()).length;
        tbl.setAutoResizeMode(jTable.AUTO_RESIZE_OFF);

        tbl.getColumnModel().getColumn(0).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(1).setPreferredWidth(prefWidth+100);
        tbl.getColumnModel().getColumn(2).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(3).setPreferredWidth(prefWidth-30);
        tbl.getColumnModel().getColumn(4).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(5).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(6).setPreferredWidth(prefWidth-20);
        tbl.getColumnModel().getColumn(7).setPreferredWidth(prefWidth+20);

Nelle ultime righe ho invece dichiarato un Renderer per settare l’allineamento al centro delle celle della jTable.

Prestate attenzione alla linea dove viene eseguita la setModel(): qui ho riscritto il metodo isCellEditable, in modo che restituisca sempre false. Così facendo qualsiasi cella della nostra jTable non potrà essere editata.

Se vi servissero esempi più dettagliati (ad esempio per inserire delle checkbox in una delle colonne o per aprire menu al pressione del tasto destro del mouse sulla tabella) fate un fischio! ;-)

Mi sono sempre promesso che prima o dopo avrei lavorato alla realizzazione di un mio tema, visto che fino ad oggi avevo sempre utilizzato temi scaricati dalla sezione apposita di wordpress e oggi ho finalmente un tema tutto mio.

Ho cercato di renderlo più leggero del precedente, riducendo al minimo il codice javascript, alleggerendo il css ed ispirandomi a design minimalisti, senza troppi fronzoli per rendere il tema intuitivo e cercando di ricordare qualche regola di HCI.

Spero vi piaccia, ma aspetto critiche e suggerimenti e ovviamente se trovate dei bugs, segnalatemeli, thanks!

Come (quasi) tutti voi bene sapete, sono un felice possessore di iPhone 3G da ormai più di 1 anno e mezzo.

Durante i primi 6 mesi di utilizzo (pre iOs 3) mancavano ancora diverse funzionalità che potevano rendere iPhone un telefono serio e non un giocattolo iper-tecnologico. Con l’arrivo dell’estate e l’introduzione di iOs 3 vennero apportate numerose aggiunte che resero iPhone un cellulare a tutti gli effetti, più tutto il resto (mentre prima era solo tutto il resto). E proprio quel “tutto il resto” permette di dire a chiunque che iPhone ha cambiato il mondo dei cellulari (non dite di no, perchè sapete di avere torto :-P ).

Quest’estate è stato nuovamente aggiornato il software di iPhone (insieme all’introduzione di iPhone 4) e dal 21 giugno scorso è disponibile per tutti i possessori di iPhone (dal 3G in avanti) iOs 4…

Be’ di primo impatto si può pensare: figo, un telefono di 2 anni fa, che viene ancora aggiornato (gratuitamente, non dimentichiamocelo). Bisogna dire che ovviamente il mio FerrePhone non possiede tutte le nuove funzionalità, pari pari ad iPhone 4, però alcune migliorie ci sono state. Tralasciando il dock 3d (di cui non me ne potrebbe fregare di meno) e gli effetti grafici allo sblocco del telefono, la funzione che trovo più utile è la cosidetta “folder” ovvero la suddivisione in cartelle delle applicazioni. Trascinando l’icona di una app sopra un’altra, queste due vengono inserite in una cartella, che prende il nome automaticamente a seconda delle affinità che ci sono tra le due app (ma che si può tranquillamente modificare).

Dopo alcuni minuti di utilizzo però, mi sono accorto che iOs4 sul mio iPhone sembrava avere qualche difficoltà. Testandolo per qualche giorno mi sono accorto che effettivamente iOs4 ha bisogno (probabilmente) di hardware più prestante, si nota infatti in alcuni momenti un rallentamento nell’apertura delle app (anche quelle di default) o effetti grafici non perfettamente fluidi. A questo punto voi mi direte: “ma che cacchio pretendi da un telefono di 2 anni fa’?”. Ok avete ragione, non posso pretendere nulla, Apple ha probabilmente deciso di rilasciare iOs4 anche per iPhone 3G nonostante probabilmente si fosse accorta che non sarebbe stato così prestante, ma per evitare critiche che sarebbero piovute a raffica, se così non avessero fatto. Ovviamente queste difetti sono “minimi” e non pregiudicano l’utilizzo normale di tutti i giorni, ma ad un occhio critico risaltano abbastanza nell’immediato. Che dire? Speriamo che a breve Apple noti questo problema e rilasci qualche aggiornamento, anche se non credo si possa fare molto (se non passare ad iPhone 4 ;) )