Entries tagged “plone”

Comprendre la « Component Architecture »

written by ccomb, on Oct 12, 2010 11:03:00 AM.

/static/python-250px.png

La Component Architecture, ou ZCA, historiquement issue de Zope 3 (qui s'appelle maintenant BlueBream), peut être utilisée pour n'importe quel projet Python, même en dehors d'une appli web. Elle trouve son intérêt lorsqu'on veut créer un programme hautement modulable, où les composants peuvent être rempacés facilement, ou même dynamiquement, sans toucher au code. Elle est aussi idéale pour créer un framework ou un CMS, et laisser la possibilité aux utilisateurs (qui sont donc, dans ce cas, développeurs ou intégrateurs), de choisir les composants ou de les surcharger par de la configuration.

Voici un petit exemple d'utilisation qui peut aider à saisir les principes.

Cet exemple est une sorte d'extrait du projet Virtual Care Team d'Etienne Saliez sur lequel je travaille de temps en temps, et donc le but est d'implémenter un dossier médical partagé entre une équipe de soin pluridisciplinaire, et de suivre l'évolution d'un problème. Après avoir fait une maquette en repoze.BFG (vct.demo), nous tentons de repartir de plus bas niveau avec le paquet vct.core, qui consiste pour l'instant en une api de stockage minimaliste, avec un plugin pour la ZODB, et un serveur XMLRPC permettant l'utilisation depuis n'importe quel langage. J'ai réutilisé ce projet pour un atelier interne de l'équipe Python à Alter Way.

Dossier médical

Le but de l'exercice est de créer un dossier médical permettant :

  • un calcul de statistiques
  • l'enregistrement dans une base de données arbitraire
  • la lecture depuis une des bases de données
  • une gestion des commentaires

On dispose d'une classe dossier médical :

>>> from dossiermedical import Dossier
>>> dossier = Dossier()

Le dossier médical possède deux attributs :

>>> dossier.patient = 'ccomb'
>>> dossier.exams = ['prise sang', 'radio du genou', 'coqueluche']

Les fonctionnalités du dossier médical sont décrites par son interface :

>>> from dossiermedical import IDossier
>>> IDossier.providedBy(dossier)
True

Voici l'implémentation du dossier, dans un fichier dossiermedical.py :

from zope.interface import Interface, Attribute, implements

class IDossier(Interface):
    patient = Attribute(u'nom du patient')
    exams = Attribute(u'liste des examens')


class Dossier(object):
    implements (IDossier)
    patient = None
    exams = None

Ajout de fonctionnalités

On souhaite ajouter deux fonctionnalités de statistiques au dossier médical : connaître sa taille et connaître la longueur moyenne des éléments. Pour ajouter des fonctionnalités, une première idée est d'ajouter des méthodes à notre Dossier (et donc aussi dans l'interface IDossier). Mais on souhaite plutôt séparer les fonctionnalités, et ne plus toucher à notre Dossier, qui est la fonctionnalité métier de base. Ceci permettra de changer le calcul des stats facilement sans toucher à l'implémentation du Dossier médical.

On décrit donc la nouvelle fonctionnalité dans une interface (qui possède deux attributs, num_exam et avg_exam) :

>>> from dossiermedical import IStat

Pour utiliser les fonctionnalités correspondant à cette interface sur le dossier médical, on utilise la notation suivante, qui signifie « donne moi la fonctionnalité IStat pour le dossier » :

>>> s = IStat(dossier)

Cette notation, qui ressemble à une instanciation de classe, permet en réalité de récupérer un adaptateur qui fournit IStat, et qui s'adapte au dossier. Pour que ça fonctionne il faut :

  • écrire l'implémentation de l'adaptateur
  • inscrire cette implémentation dans le registre de composants.

On pourra donc ensuite utiliser les méthodes de stats :

>>> s.num_exam()
3
>>> s.avg_exam()
11

Ci-dessous, voici l'implémentation de l'adaptateur, ainsi que son inscription dans le registre.

On utilise ici uniquement les paquets de la ZCA, à savoir zope.interface et zope.component. Le premier permet de définir des interfaces, tandis que le second offre le registre de composants et son API (inscription, récupération, etc.) :

from zope.component import adapts

class IStat(Interface):

    def num_exam():
        "return the number of exams"

    def avg_exam():
        "return the average lenght of the exams"


class Stat(object):
    implements(IStat)
    adapts(IDossier)

    def __init__(self, context):
        self.context = context

    def num_exam(self):
        return len(self.context.exams)

    def avg_exam(self):
        return len(''.join(self.context.exams))/self.num_exam()


# inscription dans le registre
from zope.component import getGlobalSiteManager
gsm = getGlobalSiteManager()
gsm.registerAdapter(Stat)

Ajout de plugins

On souhaite ajouter encore une fonctionnalité au dossier médical : pouvoir le stocker de différentes façons (sql, zodb, csv, ini). On commence donc par décrire la fonctionnalité dans une nouvelle interface IStockage, qui possède juste une méthode save(). :

>>> from dossiermedical import IStockage

Pour que le Dossier médical puisse fournir la fonctionnalité IStockage, on doit écrire un adaptateur fournissant IStockage, et qui s'adapte à IDossier. Comme on veut la fonctionnalité de IStockage aussi bien pour du SQL que du CSV ou du ZODB, on écrit plusieurs adaptateurs. Mais on ne peut pas inscrire dans le registre de composants plusieurs implémentations pour les même interfaces. En réalité on peut le faire, mais il faut inscrire chaque implémentataion sous un nom différent. Chaque adaptateur sera un adaptateur nommé, et le nom correspondra dans notre cas au type de base de données. Ici on ne peut pas utiliser la notation IStockage(dossier), car on veut indiquer quelle implémentation utiliser. Il faut utiliser getAdapter :

>>> from zope.component import getAdapter

On peut stocker une fois en CSV :

>>> stockage_csv = getAdapter(dossier, IStockage, "csv")
>>> stockage_csv.save()
ok, saved in CSV

Et une fois en SQL :

>>> stockage_sql = getAdapter(dossier, IStockage, "sql")
>>> stockage_sql.save()
ok, saved in SQL

Voici l'implémentation correspondante, et les inscriptions dans le registre :

class IStockage(Interface):
    def save():
        "allows to save a dossier"


class StockageCSV(object):
    implements(IStockage)
    adapts(IDossier)

    def __init__(self, context):
        self.context = context

    def save(self):
        print u"ok, saved in CSV"


class StockageSQL(object):
    implements(IStockage)
    adapts(IDossier)

    def __init__(self, context):
        self.context = context

    def save(self):
        print u"ok, saved in SQL"


# inscriptions dans le registre
gsm.registerAdapter(StockageCSV, name="csv")
gsm.registerAdapter(StockageSQL, name="sql")

Service pluggable

On souhaite maintenant récupérer notre dossier médical depuis une des sources au choix (sql, zodb, etc.). Ceci correspond encore à une nouvelle fonctionnalité, décrite par une interface ILoad. Le principe est le même que pour l'adaptateur nommé, sauf que cette fois on souhaite juste obtenir un composant qui fournit ILoad, mais qui ne s'adapte à rien. Ce type de composant s'appelle un utility :

>>> from zope.component import getUtility
>>> getUtility(IStockage, "csv").load()
ok, loaded

Voici le utility en question et son inscription dans le registre :

class ILoad(Interface):
    def load(self):
        """load the object"""

class Loader(object):
    implements(ILoad)

    def load(self):
        print u"ok, loaded"


# inscription dans le registre
gsm.registerUtility(Loader(), name="csv")

Ajout dynamique d'une fonctionnalité générique

On souhaite enfin développer une fonctionnalité générique, et réutilisable pour autre chose qu'un dossier médical : ajouter des commentaires au dossier médical. Pour obtenir une vraie généricité, on doit implémenter la fonctionnalité de commentaires sans jamais faire référence au Dossier médical.

Comment fait-on ?

La fonctionnalité de commentaire correspond à l'interface IComments. Pour utiliser cette fonctionnalité IComments sur un dossier médical, il nous faut un adaptateur fournissant IComments, et s'adaptant à IDossier. Mais comme on ne veut pas faire référence à IDossier dans notre gestion de commentaires, au lieu de créer un adaptateur s'adaptant à IDossier on crée un adapatateur s'adaptant à une interface vide, qu'on appelle interface marqueur : ICommentable. Les interfaces marqueurs sont souvent utilisées de cette façon : leur nom ressemble à un adjectif en « able », et elle indique une capacité à fournir une fonctionnalité : par exemple ICommentable, IIndexable, IStockable, etc. (C'est de cette façon que son conçues les « behaviors » dans Plone 4) :

>>> from comment import ICommentable, IComments

Comment notre dossier médical peut-il maintenant fournir la fonctionnalité de commentaire ? Il suffit d'indiquer qu'il est « commentable » en lui ajoutant dynamiquement l'interface ICommentable :

>>> from zope.interface import alsoProvides
>>> alsoProvides(dossier, ICommentable)

De cette façon, comme notre dossier médical fournit maintenant l'interface ICommentable, notre adaptateur de commentaire devient disponible :

>>> IComments(dossier).add_comment("un commentaire")

Voici la fonctionnalité de commentaire, qu'on place dans un module séparé comment.py :

from zope.interface import Interface, Attribute, implements
from zope.component import adapts


class ICommentable(Interface):
    "Add this marker interface to objects you want to be commentable"


class IComments(Interface):
    comments = Attribute("list of comments")

    def add_comment(comment):
        "add a comment"


class Comments(object):
    implements(IComments)
    adapts(ICommentable)

    def __init__(self, context):
        self.context = context
        if not hasattr(self.context, '_comments'):
            self.context._comments = []
        self.comments = self.context._comments

    def add_comment(self, comment):
        self.comments.append(comment)


# inscription dans le registre
from zope.component import getGlobalSiteManager
gsm = getGlobalSiteManager()
gsm.registerAdapter(Comments)

Conclusion

Cet exemple a couvert les notions suivantes de la ZCA :

  • adaptateur simple
  • adaptateur nommé
  • utility
  • interface marqueur et fonctionnalité générique

Parmi les notions non abordées, on trouve les adaptateurs multiples, qui sont exatement la même chose que les adaptateurs simples (sauf qu'ils s'adaptent à plusieurs objets), ou bien les subscribers (adaptateurs d'abonnement). Pour en savoir plus, consultez le Guide complet de la ZCA

Comparing Plone and Drupal speed evolutions

written by ccomb, on Oct 9, 2010 12:55:00 AM.

Ok, testing the home page of a CMS is generally a bad idea, it is not representative of the responsiveness of the application when people eventually use it. Anyway I did it. I had seen a few benchmarks comparing Plone 4 to previous versions, and comparing Plone with Joomla, Drupal or Wordpress. So I just wanted to check it by myself.

Comparing the homepages of successive Plone versions is perfectly relevant because their contents are very similar. Comparing the homepage of Plone and Drupal is not fair : a default Drupal without modules is pretty useless and offers almost nothing. A default Plone can be used without additional modules to create any website or intranet and offers a lot of features.

So I've installed all major versions of Plone since 2.5, and Drupal 5, 6 and 7 alpha7, without optimisations, and without caching.

The conclusions are:

  • Anyone running a Plone 2.5 or 3.x should seriously consider a migration to Plone 4. This will not always be easy, but it's possible. We, at Alter Way, are conducting a test consisting of a migration of an even older Plone 2.0 site with deprecated products, to 4.0.
  • Each new version of Plone is faster, while each new version of Drupal is slower.
  • Plone 4 (and even 4.0.1) is available now, while Drupal 7 release date is uncertain.

Please note that the interesting point of this curve is not the absolute number of req/s, but the slope of the curve.

comparing plone and drupal speed evolutions

test