Preparariamo un Ambiente Virtuale

Prima di poter iniziare a lavorare sulla nostra applicazione, è sempre una buona idea preparare un ambiente python che sia isolato dal python di sistema nella vostra distribuzione linux (nel mio caso, Ubuntu Gutsy).

Creando un ambiente python "virtuale", possiamo facilmente evitare molti problemi associati al python di sistema, come pacchetti rotti, dipendenze conflitto, etc.

Un ambiente virtuale python può essere facilmente creato usando lo script virtualenv.py disponibile da http://svn.colorstudy.com/virtualenv/trunk/virtualenv.py. Per la documentazione relativa a quello che fa lo script, date un'occhiata alla pagina pypi http://pypi.python.org/pypi/virtualenv.

Scaricate questo script nella vostra directory home e create un nuovo ambiente chiamato sandbox:

$ wget http://svn.colorstudy.com/virtualenv/trunk/virtualenv.py ~/
$ python ~/virtualenv.py sandbox

In alternativa potete creare questo ambiente dovunque preferite, e chiamarlo come volete.

Questa cartella ora ha una directory bin con un nuovo eseguibile python e uno nuovo script easy_install. Dispone anche di uno script bash per collocare la vostra shell nel nuovo ambiente, in modo che non dovrete scrivere l'intero path per lanciare il python dell'ambiente. Lanciatelo così:

$ cd sandbox
$ source bin/activate

Dopo di che potrete verificare che sta funzionando:

(sandbox)$ which python
/home/pcardune/sandbox/bin/python

Da questo punto in poi, dovunque vedrete un comando shell da lanciare, si assume che abbiate l'ambiente virtuale attivato.

Uso di zopeproject

Risulta conveniente iniziare con uno scheletro di applicazione di base in modo da non doversi preoccupare di scrivere tutte le configuarazioni di base da zero. Fortunatamente Philipp von Weitershausen ha scritto un ottimo strumento chiamato zopeproject per farlo.

zopeproject può essere installato usando easy_install. Scrivete semplicemente:

$ easy_install zopeproject

Sucessivamente creiamo un nuovo progetto chiamato zcontact. zopeproject crea tutta la configurazione di base di cui avrete bisogno per essere in grado di avviare immediatamente un'applicazione zope vuota e loggarsi con un account di amministrazione. Vi sarà chiesto uno username e una password iniziali per l'account di amministrazione (che può essere cambiato in qualsiasi momento) insieme a una collocazione dove installare i componenti necessari:

$ zopeproject zcontact
Enter user (Name of an initial administrator user): manager
Enter passwd (Password for the initial administrator user): zcontact
Enter eggs_dir (Location where zc.buildout will look for and place packages)   ['/home/pcardune/buildout-eggs']: eggs

Questa fase potrebbe richiedere parecchi minuti poichè molto codice deve essere scaricato e in parte compilato. Mentre aspettate, vi consiglio di dare un'occhiata alla documentazione di zopeproject per averne un'idea migliore di cosa stia facendo.

Avviamo il Server

Finito questo, potrete saltare a bordo immediatamente e avviare la vostra applicazione nascente che sarà in esecuzione alla porta 8080 di default:

$ cd zcontact
$ ./bin/paster serve deploy.ini
Starting server in PID 23818.
serving on http://127.0.0.1:8080

Dovreste aver ottenuto una schermata zope vuota che assomiglia a quella sotto:

Il file deploy.ini dato al comando ./bin/paster specifica le opzioni per eseguire il server, come l'impostazione delle porte. zopeproject genera anche un file debug.ini che include un filtro WSGI per la gestione degli errori. Se mai incapperete in errori, potrete usare le configurazioni nel debug.ini per ispezionare il codice, mentre è in esecuzione, direttamente nel vostro browser web!

Sistemiamo la Sicurezza

Per Tenere Semplici le Cose (Stupido) in questo tutorial, modificheremo i permessi generati da zopeproject in modo da non dovercene preoccupare dopo. Aggiungete le seguenti linee al file site.zcml nella directory root della vostra applicazione:

<role id="zope.Anonymous" title="Everybody" />
<grantAll role="zope.Anonymous" />

Questo offre agli utenti anonimi accesso completo senza restrizioni.

Creiamo una Semplice Interfaccia e Implementazione

Prima di poter saltare nel mondo dei pacchetti z3c.*, dovremo disporre di alcuni oggetti con cui voler giocare. Poichè si suppone che ZContact sia un gestore di contatti, iniziamo con un oggetto contact. Per Farla Semplice (Stupido), avremo solo due campi, un first name e un last name.

Nota

Tutto il codice sorgente si trova nella cartella zcontact/src/zcontact in modo che zcontact/src/zcontact/interfaces.py possa essere importato con un import zcontact.interfaces

import zope.interface
import zope.schema

class IContact(zope.interface.Interface):
"""A simple contact."""

  firstName = zope.schema.TextLine(
      title=u"First Name",
      required=True)

  lastName = zope.schema.TextLine(
      title=u"Last Name",
      required=True)

import zope.interface
from zope.schema.fieldproperty import FieldProperty

import interfaces

class Contact(object):
   """See ``zcontact.interfaces.IContact``."""
   zope.interface.implements(interfaces.IContact)

   firstName = FieldProperty(interfaces.IContact['firstName'])
   lastName = FieldProperty(interfaces.IContact['lastName'])

<class class="zcontact.contact.Contact">
 <require
     interface=".interfaces.IContact"
     permission="zope.View" />
 <require
     set_schema=".interfaces.IContact"
     permission="zope.ManageContent" />
</class>

Attenzione!

Non dimenticate, nel mondo reale scrivereste prima degli unit test per questo codice, anche solo per assicurarsi che la classe Contact veramente implementa l'interfaccia IContact.