Fichier 1 - Paroles de Catholiques

Plone pour les intégrateurs
Version 1.0.0
plone-fr
27-June-2012
Table des matières
1
2
3
A propos de ce document
1.1 Organisation . . . . . .
1.2 Liste des thèmes abordés
1.3 Ressources . . . . . . .
1.4 Version . . . . . . . . .
1.5 Changements . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
3
3
4
4
Présentation de Plone
2.1 Les besoins . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Pourquoi Plone . . . . . . . . . . . . . . . . . . . . . . .
2.3 Centralisation des documents . . . . . . . . . . . . . . .
2.4 Édition des contenus . . . . . . . . . . . . . . . . . . . .
2.5 Visualisation des documents . . . . . . . . . . . . . . . .
2.6 Classement des documents . . . . . . . . . . . . . . . . .
2.7 Stockage des documents . . . . . . . . . . . . . . . . . .
2.8 Authentification . . . . . . . . . . . . . . . . . . . . . .
2.9 Permissions, rôles et groupes d’utilisateurs . . . . . . . .
2.10 Indexation . . . . . . . . . . . . . . . . . . . . . . . . .
2.11 Photothèques . . . . . . . . . . . . . . . . . . . . . . . .
2.12 Fonction d’alerte . . . . . . . . . . . . . . . . . . . . . .
2.13 Actualités, événements, calendrier, lettres d’informations .
2.14 Espace projet . . . . . . . . . . . . . . . . . . . . . . . .
2.15 Répertoires dynamiques . . . . . . . . . . . . . . . . . .
2.16 Références croisées . . . . . . . . . . . . . . . . . . . .
2.17 Modération du contenu . . . . . . . . . . . . . . . . . . .
2.18 Historique des changements effectués sur le contenu . . .
2.19 Flux RSS . . . . . . . . . . . . . . . . . . . . . . . . . .
2.20 Langue du portail, Multilinguisme, Traduction . . . . . .
2.21 Charte graphique . . . . . . . . . . . . . . . . . . . . . .
2.22 Trombinoscope et annuaires . . . . . . . . . . . . . . . .
2.23 Génération de documents à partir de modèles . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
5
5
6
6
11
12
12
12
12
14
14
14
15
15
15
15
15
17
18
18
20
20
20
Les nouveautés de Plone 3
3.1 Édition en ligne . . . . . . . . . . . . . . . .
3.2 Validation des champs via AJAX . . . . . .
3.3 Support des copies de travail . . . . . . . . .
3.4 Vérification de l’intégrité des liens . . . . . .
3.5 Verrouillage d’un document lors de l’édition
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
23
23
23
23
24
24
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
i
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
4
5
6
7
8
9
ii
Nouvel onglet partage . . . . . . . . . . . . . . .
Versionnement des documents . . . . . . . . . . .
Visualiser un document en mode diaporama . . . .
Navigation Précédent/Suivant dans un dossier . . .
Générer une table des matières pour un document .
Indexage des documents Word et PDF . . . . . . .
Mais aussi . . . . . . . . . . . . . . . . . . . . .
Et pour le développeur . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
24
24
24
24
25
25
25
25
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
27
27
28
28
28
29
29
30
Paramétrer votre site Plone
5.1 Objectif . . . . . . . . . . . . . . . . . . . . . . .
5.2 Accéder au menu de configuration . . . . . . . . .
5.3 Configurer les paramètres de messagerie . . . . .
5.4 Paramètres du site . . . . . . . . . . . . . . . . .
5.5 Paramètres de base de la sécurité du site . . . . . .
5.6 Paramétrage du calendrier . . . . . . . . . . . . .
5.7 Paramétrage de la navigation . . . . . . . . . . . .
5.8 Paramètres de la recherche . . . . . . . . . . . . .
5.9 Configurer le thème . . . . . . . . . . . . . . . .
5.10 Paramétrage des modules . . . . . . . . . . . . .
5.11 Paramétrage des règles de contenu . . . . . . . . .
5.12 Paramétrer l’édition de contenus . . . . . . . . . .
5.13 Paramétrer le filtrage du contenu ajouté en HTML
5.14 Paramétrer le comportement wiki . . . . . . . . .
5.15 Gestion des tailles d’images . . . . . . . . . . . .
5.16 Maintenance du serveur et de la base . . . . . . .
5.17 Choix de la langue du Site . . . . . . . . . . . . .
5.18 Paramétrer les collections . . . . . . . . . . . . .
5.19 Paramétrer les types de contenu . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
31
31
31
32
34
35
37
42
47
51
51
51
53
55
61
62
62
64
64
64
Choix et ajout d’un module
6.1 Introduction . . . . . . . . . . . . .
6.2 Rechercher et sélectionner un module
6.3 Installer un module . . . . . . . . . .
6.4 Tester le module . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
73
73
74
74
75
Le protocole HTTP et ses tests
7.1 Définition . . . . . . . . .
7.2 Savoir . . . . . . . . . . .
7.3 Exercice . . . . . . . . .
7.4 Ressources . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
77
77
78
82
83
Rappel HTML et XML
8.1 Définition . . . . .
8.2 Savoir . . . . . . .
8.3 Exercices . . . . .
8.4 Ressources . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
85
85
86
89
89
Concept de Python eggs
9.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
91
Les nouveautés de Plone 4
4.1 Performances . . . . . . . . . . . . . . .
4.2 Thème . . . . . . . . . . . . . . . . . .
4.3 Ergonomie . . . . . . . . . . . . . . . .
4.4 Amélioration de l’administration du site .
4.5 Amélioration de la customisation du site
4.6 Améliorations techniques . . . . . . . .
4.7 Migration de Plone 3.3 vers Plone 4 . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9.2
9.3
9.4
9.5
9.6
9.7
9.8
Savoir . . . . . . . . . . . . . . . . . . . . . . . . . . .
Installation de Python et Distribute . . . . . . . . . . .
Packaging Python . . . . . . . . . . . . . . . . . . . .
Passons au développement . . . . . . . . . . . . . . . .
L’API pkg_resources . . . . . . . . . . . . . . . . . . .
Les entry points . . . . . . . . . . . . . . . . . . . . .
Mise en place d’un Pypi privé avec PloneSoftwareCenter
10 Introduction à zc.buildout
10.1 Définition . . . . . . . . . . . . . . . . . .
10.2 Introduction . . . . . . . . . . . . . . . .
10.3 Organisation d’un buildout . . . . . . . . .
10.4 Section principale [buildout] . . . . . . . .
10.5 Partage du dossier eggs et downloads . . .
10.6 Pinning des versions . . . . . . . . . . . .
10.7 Extension buildout.dumppickedversions . .
10.8 Option extends . . . . . . . . . . . . . . .
10.9 Recipe collective.recipe.omelette . . . . .
10.10 Utilisation de variable . . . . . . . . . . .
10.11 Repinning et fusion de section de données .
10.12 Ordre d’installation des parts . . . . . . . .
10.13 L’option develop . . . . . . . . . . . . . .
10.14 Option index et find-links . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. 91
. 92
. 92
. 99
. 104
. 104
. 105
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
109
109
110
110
110
112
113
113
114
115
116
117
117
118
118
11 Installation et création d’une instance Plone
121
11.1 Savoir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
11.2 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
12 Création d’un buildout Plone avec ZopeSkel
12.1 Création du buildout . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2 Installation de produits tierces . . . . . . . . . . . . . . . . . . . . . . .
12.3 Création d’un policy package contenant la configuration du site Plone . .
12.4 À propos des versions . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.5 Releaser le policy package . . . . . . . . . . . . . . . . . . . . . . . . .
12.6 Repasser au développement . . . . . . . . . . . . . . . . . . . . . . . .
12.7 Utilisation de mr.developer pour gérer les composants en développement
12.8 Fabric . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.9 Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
129
130
132
132
138
138
140
140
141
142
13 Déploiement et backup
13.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.2 Savoir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.3 Profil de déploiement . . . . . . . . . . . . . . . . . . . . . .
13.4 Supervisor . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.5 Support des backups . . . . . . . . . . . . . . . . . . . . . .
13.6 Cron job pour zeopack et backup . . . . . . . . . . . . . . .
13.7 Configuration d’Apache . . . . . . . . . . . . . . . . . . . .
13.8 Configuration des DNS . . . . . . . . . . . . . . . . . . . . .
13.9 Installation et configuration de CacheFu (< Plone 4) . . . . .
13.10 Installation et configuration de plone.app.caching (>= Plone 4)
13.11 Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.12 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
143
144
144
144
148
149
149
150
152
152
152
154
154
14 Zope External Editor
14.1 Activation du lien “Modifier avec une application externe”
14.2 Installation du client External Editor sous Ubuntu . . . . .
14.3 Installation du client External Editor sous Windows . . .
14.4 Problèmes de cache avec l’External Editor . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
155
155
155
156
156
.
.
.
.
.
.
.
.
iii
15 Monitoring avec Munin
15.1 Plugins Zope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2 Plugins Varnish . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.3 Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
159
160
161
161
16 PloneFormGen
163
16.1 Présentation de PloneFormGen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
16.2 Exercice : Réalisation d’un formulaire de sondage . . . . . . . . . . . . . . . . . . . . . . . . . 174
17 TAL/Metal les templates de Zope et Plone
17.1 Le langage TAL . . . . . . . . . . .
17.2 TALES . . . . . . . . . . . . . . . .
17.3 METAL . . . . . . . . . . . . . . . .
17.4 Ressources . . . . . . . . . . . . . .
17.5 Namespaces . . . . . . . . . . . . .
17.6 Variables globales . . . . . . . . . .
17.7 Présentation des ZPT . . . . . . . . .
17.8 Le langage TAL . . . . . . . . . . .
17.9 TALES . . . . . . . . . . . . . . . .
17.10 METAL . . . . . . . . . . . . . . . .
17.11 Exercice . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
175
176
177
177
177
177
178
178
179
180
182
183
18 Paramétrage local des workflows
18.1 Préparation . . . . . . . . . . . . .
18.2 Installation du module . . . . . . .
18.3 Gestion des politiques de workflow
18.4 Affectation des workflows locaux .
18.5 Export Generic Setup . . . . . . .
18.6 Conclusion . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
185
185
185
188
191
191
191
19 Déclenchement d’événements avec les règles de contenu
19.1 Objectif de la formation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.2 Préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.3 Créer une règle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.4 Paramétrer une règle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.5 Créer une condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.6 Créer une action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.7 Activer la règle pour une partie du site . . . . . . . . . . . . . . . . . . . . . . . . .
19.8 Tester la règle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.9 Exemple 2 : Logguer les suppressions de documents . . . . . . . . . . . . . . . . .
19.10 Exemple 3 : Déplacer les événements dans un même dossier, où qu’ils soient ajoutés
19.11 Export Generic Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.12 Extensibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19.13 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
195
195
196
196
196
198
198
199
202
202
203
203
204
204
20 Créer des pages composées en ligne avec Collage
20.1 Préparation . . . . . . . . . . . . . . . . . .
20.2 Objectif de la formation . . . . . . . . . . .
20.3 Installer Products.Collage . . . . . . . . . .
20.4 Créer un Collage . . . . . . . . . . . . . . .
20.5 Ajouter les éléments du Collage . . . . . . .
20.6 Utiliser le collage comme page d’accueil . .
20.7 Paramétrer l’affichage du collage . . . . . .
20.8 Extensibilité . . . . . . . . . . . . . . . . .
20.9 Conclusion . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
205
205
205
205
206
206
210
210
214
214
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
21 Glossaire
223
22 Indexes et tables
227
iv
23 Contributeurs
229
Index
231
v
vi
Plone pour les intégrateurs, Version 1.0.0
Astuce : Pour voir cette documentation dans son site original et accéder à son moteur de recherche, veuillez vous
rendre ici.
Lire la dernière version de ce document au format PDF
Ce document constitué à partir de contributions de la communauté Plone francophone, notamment :
– Le manuel de formation intégrateur Plone par Vincent Fretin (Ecréall)
– Les travaux, les relectures et les très nombreuses contributions de Gilles Lenfant, Thomas Desvenain et Michael
Launay
Cette création est mise à disposition selon le Contrat Paternité-Partage des Conditions Initiales à l’Identique 2.0
France disponible en ligne http ://creativecommons.org/licenses/by-sa/2.0/fr/ ou par courrier postal à Creative
Commons, 171 Second Street, Suite 300, San Francisco, California 94105, USA.
Table des matières
1
Plone pour les intégrateurs, Version 1.0.0
2
Table des matières
CHAPITRE 1
A propos de ce document
1.1 Organisation
La formation est découpée en thèmes.
Presque chaque thème comprend :
– un objectif,
– un savoir à acquérir,
– un exercice pratique permettant de fixer le savoir acquis,
– un bilan oral, résumant ce qui a été acquis.
1.2 Liste des thèmes abordés
–
–
–
–
–
–
–
–
–
–
–
–
–
Présentation des nouveautés de Plone 3 et 4
Concept de Python eggs
Création d’un buildout Plone 3 avec paster
Concepts de base Zope 3
Migration des composants développés pour Plone 2.5
Migration d’un portail Plone 2.5 à Plone 3
Déploiement et backup
Formation de TAL/Metal permettant l’écriture de pages dynamiques
Envoi de mail suite à un évènement sur le portail
Internationalisation d’un composant
Notions avancées de formulaire d’édition
Nouvelles fonctionnalités de ArchGenXML
Création d’un thème Plone 3 (avec paster)
1.3 Ressources
Livres de Packt Publishing, en anglais :
– Practical Plone 3 : A Beginner’s Guide to Building Powerful Websites, Alex Clark, Clayton Parker, Darci
Hanning, David Convent, John DeStefano, Jon Stahl, Martin Aspeli, Matt Bowen, Ricardo Newbery, Sam Knox,
Steve McMahon, Tom Conklin, Veda Williams, février 2009
– Plone 3 Theming, Veda Williams, juillet 2009
– Plone 3 for Education, Erik Rose, décembre 2009
– Plone 3.3 Site Administration, Alex Clark, mars 2010
– Plone 3.3 Multimedia, Tom Gross, juin 2010
3
Plone pour les intégrateurs, Version 1.0.0
1.4 Version
0.1
Le contenu de cette version est validé, mais n’est pas considéré comme publiable en l’état
1.5 Changements
0.1 - Première version de la documentation intégrateur
4
Chapitre 1. A propos de ce document
CHAPITRE 2
Présentation de Plone
Author Michael Launay
Version 0.1.0
Révision https ://svn.plone.org/svn/collective/collective.trainingmanual/trunk/fr/integrateur/source/presentation_plone.txt
Copyright (C) 2010 Michael Launay <michaellaunay AT ecreall.com>.
Chacun est autorisé à copier, distribuer et/ou modifier ce document suivant les termes de la licence
Paternité-Pas d’Utilisation Commerciale-Partage des Conditions Initiales à l’Identique 2.0 France accessible à
http ://creativecommons.org/licenses/by-nc-sa/2.0/fr
Le code source présent dans ce document est soumis aux conditions de la « Zope Public License », Version 2.1
(ZPL).
THE SOURCE CODE IN THIS DOCUMENT AND THE DOCUMENT ITSELF IS PROVIDED “AS IS” AND
ANY AND ALL EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT,
AND FITNESS FOR A PARTICULAR PURPOSE.
2.1 Les besoins
Plone permet de satisfaire les besoins d’espaces collaboratifs pour organiser, partager et diffuser des informations
et des documents.
Il permet de centraliser et référencer l’information pour l’utilisateur via une interface web intuitive.
Il fournit une vitrine et un outil d’animation.
Nous montrerons comment le CMS open source Plone répond aux exigences fortes que sont :
– Un usage simple et ergonomique pour l’utilisateur.
– Un fort niveau de paramétrage pour l’administrateur.
2.2 Pourquoi Plone
Plone est une solution open source multiplateforme, performante, stable et sûre qui existe depuis 2001.
Le CMS Plone évolue constamment sans perte de compatibilité. Il est maintenu par une communauté de sociétés
qui en assure la pérennité et l’adéquation avec le besoin des clients.
En France on trouve pas moins de 11 sociétés spécialisées réalisant en support expert sur cette technologie sur les
336 sociétés mondiales réparties sur 62 pays (C.f. ).
5
Plone pour les intégrateurs, Version 1.0.0
2.3 Centralisation des documents
Le portail collaboratif Plone est un un espace unique où trouver et échanger des informations. Il se présente sous
la forme d’un site internet accessible en intranet comme en extranet.
Le fonctionnement client-serveur d’internet offre naturellement la centralisation voulue.
Les utilisateurs saisissent l’URL du portail depuis leur navigateur internet, s’authentifient, et accèdent alors aux
documents de l’entreprise.
2.4 Édition des contenus
L’édition des contenus se fait par une étape de création, suivie automatiquement d’une édition, d’un enregistrement
puis éventuellement d’un changement d’état.
L’utilisateur se place dans une partie de l’arborescence du site en utilisant la navigation.
S’il en a les droits il peut alors ajouter un contenu qui peut être un document, d’événement, de répertoire, de fichier
ou tout type créé spécifiquement, etc.
F IG . 2.1 – Exemple de navigation
Une fois placé à l’endroit voulu dans l’arborescence, l’utilisateur choisit le type d’élément voulu dans le menu
“Ajout d’un élément”.
Une page sur l’édition du nouveau document s’ouvre et l’on peut saisir le contenu du document :
Le portail vérifie les saisies lorsqu’on passe d’un champ à l’autre.
Une fois la saisie réalisée, il suffit de cliquer sur le bouton “Enregistrer”.
Tant que l’enregistrement n’est pas fait le nouveau contenu est en mode brouillon, c’est-à-dire qu’il n’est pas
réellement ajouté à l’arborescence.
6
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
F IG . 2.2 – Ajout d’un élément
F IG . 2.3 – Création d’un document
2.4. Édition des contenus
7
Plone pour les intégrateurs, Version 1.0.0
L’édition des contenus se fait par l’intermédiaire de formulaires propres à chaque type.
F IG . 2.4 – Exemple d’édition d’un document
On peut remarquer dans cette capture l’éditeur en ligne qui permet une mise en forme riche avec création de titre,
changement de police, de couleur, insertion de listes numérotées, d’images pouvant être retaillées...
De nombreuses fonctionnalités de cet éditeur peuvent être paramétrées par l’administrateur (boutons disponibles,
etc)
Chaque type de document possède une liste de méta-informations telles que l’auteur, la date de création, la date
de publication, la date de retrait du document, etc.
Il est à noter que toutes les méta-informations sont remplies par défaut avec les valeurs issues du contexte.
L’édition des méta-informations se fait par clic sur l’onglet voulu, ici nous avons appuyé sur “Catégorisation”.
Pour ajouter de nouveaux mots-clés, il suffit lorsqu’on a les droits de les entrer dans l’encart “Nouveaux motsclés”.
L’onglet date permet de préciser la période de publication d’un élément. Ici le document sera visible entre le 16
juin 2010 et le 30 juillet.
8
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
F IG . 2.5 – Association de mots clés aux documents
F IG . 2.6 – Date de publication d’un document
2.4. Édition des contenus
9
Plone pour les intégrateurs, Version 1.0.0
F IG . 2.7 – Propriété d’un élément
10
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
L’onglet propriété permet de gérer les notions de droit d’auteur.
F IG . 2.8 – Paramètres d’un document
L’onglet paramètres permet de préciser comment le document sera visible dans l’arborescence et si l’on autorise
les commentaires.
Seul l’onglet “contenu” est obligatoire, les autres sont remplis par défaut et peuvent être cachés aux utilisateurs.
Une fois que l’on a “enregistré”, le document s’affiche en mode consultation et l’on peut alors changer son état en
cliquant sur l’onglet affichant l’état (ici “Privé”).
2.5 Visualisation des documents
La visualisation des documents, que ce soient des fichiers, des pages, des images, des liens, des actualités, des
événements, permet des mises en formes élaborées reposant sur les dernières techniques du web.
Si les documents à partager via le portail sont des images ou des fichiers produits par les outils de bureautique classique (suite Microsoft office, Open Office, PDF, etc.), ils pourront être prévisualisés directement sur le navigateur
internet des utilisateurs.
Plone peut embarquer des outils permettant de transformer des documents Word, Excel, PowerPoint, etc, en page
web. Dès lors un simple navigateur internet suffit pour les consulter.
2.5. Visualisation des documents
11
Plone pour les intégrateurs, Version 1.0.0
2.6 Classement des documents
La création et le dépôt des documents peuvent suivre les règles de classement des documents édictées par les habitudes des utilisateurs. Il est donc possible de garantir le respect d’un plan documentaire défini par des procédures
qualités.
Ce classement est naturel, le portail possède un espace de navigation qui se présente comme une arborescence de
fichiers, en conséquence Plone ne permet de créer les documents et sous-répertoires que là où ils ont du sens.
On peut définir des types de sous-répertoires n’acceptant que certains types d’éléments, par exemple un répertoire
Photothèque ne contiendra que des images.
Autre exemple, le répertoire Présentation ne permettra que le dépôt des documents respectant le modèle des
présentations.
Le plan documentaire peut être établi dynamiquement en ligne par les utilisateurs du site – selon leurs droits et/ou être défini de manière statique.
2.7 Stockage des documents
Le portail est une zone d’échange et d’archivage des contenus, qui permet de savoir qui a déposé un document, et
quand.
Il gère le temps de visibilité des documents et les droits de consultation ou de modification.
Les documents, les changements effectués, la liste des membres sont stockés par défaut dans une base de données
objet. Il est possible d’utiliser notre solution avec d’autres bases de données, relationnelles ou non.
2.8 Authentification
Seules les personnes habilitées à voir les documents les voient, seules celles habilitées à les modifier peuvent le
faire.
Chaque utilisateur de Plone possède son propre login et mot de passe.
Ils peuvent être spécifiques au site ou issus d’une source externe, comme un annuaire LDAP (l’Active Directory
de Microsoft par exemple).
Il est très aisé de combiner différentes sources.
Des solutions existent pour gérer la connexion par SSO.
Dans ce cas, l’utilisateur connecté à sa session de Windows (par exemple) est automatiquement logué au site
quand il y accède.
2.9 Permissions, rôles et groupes d’utilisateurs
Chaque état d’un type de contenu définit les permissions nécessaires à sa création, sa consultation, à son édition
et sa suppression.
Un utilisateur possède un ou plusieurs rôles qui lui attribuent ou non les permissions sur les contenus parcourus.
On peut définir autant de rôles que voulus.
Il est possible de réunir plusieurs rôles dans des groupes auxquels appartiennent plusieurs utilisateurs (administrateur, relecteur, membre, anonyme, authentifié, etc). En conséquence, un utilisateur possède un ou plusieurs rôles,
et un rôle peut lui être attribué de façon locale dans un dossier, ou attribué par les groupes auxquels il appartient.
Les administrateurs peuvent aisément créer des groupes et les gérer.
12
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
F IG . 2.9 – Authentification par login et mot de passe
F IG . 2.10 – Gestion des utilisateurs
2.9. Permissions, rôles et groupes d’utilisateurs
13
Plone pour les intégrateurs, Version 1.0.0
La gestion des permissions se fait à travers le mécanisme des ACL (Access Control List).
La gestion des utilisateurs, des rôles, et des groupes se fait à travers une interface relativement simple.
2.10 Indexation
Le portail offre des fonctions de recherche simple et complexe, sur le contenu des documents et les métainformations.
Le texte des documents saisis en ligne ou téléchargés (pour les formats les plus courants : Word, Excel, Power
Point, pdf, etc.) est indexé.
Le moteur de recherche rapide est constitué d’un champ présent en permanence sur toute les pages.
Il permet d’effectuer des recherches rapides.
La recherche de l’utilisateur est analysée au fur et à mesure de la saisie, des propositions sont faites automatiquement à partir des données de la base.
Un formulaire de recherche détaillé permet de filtrer la recherche en fonction des méta-informations, et de lier les
critères entre-eux avec les mots-clés OR et AND.
F IG . 2.11 – Recherche dynamique
L’indexation des éléments (document, fichier, événements) est entièrement paramétrable.
2.11 Photothèques
Les images, dessins, photos peuvent être gérées dans des galeries permettant leur manipulation, visualisation,
recherche et intégration aux documents rédigés en ligne.
Plone permet de retailler les images, de les afficher sous forme de vignettes, ou dans des diaporamas.
2.12 Fonction d’alerte
Les membres du portail peuvent être prévenus lorsque des mises à jour ou des modifications ont été réalisées sur
les documents.
Un mécanisme événementiel permet de réaliser des actions lorsque certaines choses se produisent sur le portail
(nouvel utilisateur, publication d’un document...).
Toutefois, la façon standard de notifier les contenus modifiés récemment, ou à modérer est d’afficher leur liste à
droite ou à gauche du contenu publié.
14
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
2.13 Actualités, événements, calendrier, lettres d’informations
Les actualités et les événements sont des types de base de Plone, le calendrier affiche les événements que l’on est
autorisé à voir en fonction de ses rôles, ou groupes.
La liste des événements est accessible par simple clic sur l’onglet “Événements”.
Les dernières actualités sont accessibles en cliquant sur l’onglet “Actualités”.
Ces deux listes peuvent être affichées directement à gauche ou à droite du contenu.
Ce placement est paramétrable en ligne par l’administrateur (par exemple en dessous du calendrier).
Plusieurs types de lettres d’informations sont possibles, il est facile de modifier la charte graphique des lettres.
Le système de lettres d’informations permet de gérer les abonnements désabonnements et peut déléguer à l’émetteur de choisir les membres ou groupes devant la recevoir.
2.14 Espace projet
Le portail permet facilement de mettre en place la notion de projet, et offre donc :
1. un calendrier qui tient compte de vos droits pour afficher les événements,
2. des listes de tâches,
3. des classeurs de documents (containers),
4. des forums,
5. des sondages,
6. des actualités.
2.15 Répertoires dynamiques
Il est également possible de créer ses propres “collections” de documents : il s’agit de répertoires dont le contenu
est en réalité le résultat d’un recherche basée sur des filtres.
Il peuvent être emboité les uns dans les autres et en modifiant les critère de recherche, on peut ainsi créer des
répertoires transversaux au plan documentaire.
2.16 Références croisées
Le portail permet de “lier” des documents entre-eux. Exemples :
1. Fiche descriptive d’un produit et différentes photos d’applications de ce produit.
2. Associer un document en anglais et des traductions faites à partir de ce document.
La notion de lien internet est fortement utilisée et permet à Plone de créer des références entre documents.
2.17 Modération du contenu
Certaines personnes peuvent avoir pour charge d’accepter ou non la publication des documents sur le portail.
Plone permet ceci comme la plupart des CMS (Content Management System) du marché, mais il ne fige pas la
chaîne de validation (Workflow), que l’on peut modifier.
Par exemple nous avons défini le workflow des tâches de la gestion des projets comme suit :
Les états définissent les permissions à avoir pour par exemple voir ou modifier les documents, en les attribuant ou
non à des rôles.
2.13. Actualités, événements, calendrier, lettres d’informations
15
Plone pour les intégrateurs, Version 1.0.0
F IG . 2.12 – Exemple de workflow
16
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
Les transitions définissent qui a le droit de changer les états des documents, dans quelles conditions et quels sont
alors les traitements à réaliser.
Les utilisateurs voient les transitions qu’ils peuvent exécuter.
F IG . 2.13 – Changement d’état d’un élément
La mise en place de chaîne de validation des documents autres que ceux prévus par défaut, passe par la création
d’états et transitions. Ceci se fait soit directement à travers l’interface d’administration de Plone soit par l’utilisation d’outils spécifiques.
La possibilité de créer simplement et efficacement les workflows associés aux documents déposés ou créés sur le
portail est l’un des grands atouts de Plone.
La précision de paramétrage des permissions permet de cacher ou montrer les champs d’un document en fonction
de l’état du document et des rôles de l’utilisateur.
Il est possible de modéliser les workflows en utilisant les outils graphiques basés sur UML (Unified Model Language), Argouml et ArchgenXML.
Les administrateurs peuvent modifier les workflows soit en utilisant ces même outils, soit le faire directement à
travers le web une fois authentifiés sur le portail.
2.18 Historique des changements effectués sur le contenu
Le système trace toutes actions. De plus il permet de revenir à l’état précédent pour chaque action.
Ainsi pour les document nous avons un historique pour les changement d’états et pour les modifications apportées.
L’historique permet de voir les changements du document que ce soit les états ou les modifications du contenu.
En comparant deux versions ensemble on peut voir les modifications apportées.
2.18. Historique des changements effectués sur le contenu
17
Plone pour les intégrateurs, Version 1.0.0
F IG . 2.14 – Affichage de l’historique d’un élément
Ici nous voyons que l’image a été déplacée et qu’un paragraphe a été ajouté.
Il est facile de revenir à une version précédente, puisqu’il suffit de cliquer sur les boutons “revenir à cette version”
que l’on voit dans l’historique.
2.19 Flux RSS
Plone propose nativement l’intégration des flux RSS, ce qui permet aux habitués d’utiliser leur lecteur de flux rss
pour savoir s’ils ont des documents à lire.
2.20 Langue du portail, Multilinguisme, Traduction
Plone est multi-langue et permet de traduire chaque document ou formulaire en plusieurs langues.
Actuellement prés de 80 langues sont supportées et 32 le sont complètement.
Pour rajouter une langue non encore supportée par exemple le “Picard”, il suffit de traduire un ensemble de fichiers
linguistiques.
Les contributeurs peuvent traduire les articles dans une des langues activées pour le site.
Quand un contenu est traduit, les visiteurs du site le consultent dans leur propre langue.
S’il n’est pas traduit dans leur langue, ils le consultent dans la langue par défaut.
18
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
F IG . 2.15 – Différences entre deux versions d’un élément
2.20. Langue du portail, Multilinguisme, Traduction
19
Plone pour les intégrateurs, Version 1.0.0
2.21 Charte graphique
Plone utilise la technologie CSS2 pour réaliser les feuilles de styles permettant d’avoir le design approprié.
Le placement des composants tels que le calendrier est facilement effectué en ligne ou par fichier de configuration.
F IG . 2.16 – Exemple de style basique
Il est possible d’adapter des chartes existantes à vos besoins en changeant par exemple les couleurs, les icônes.
2.22 Trombinoscope et annuaires
Le portail, fournit un trombinoscope des membres.
2.23 Génération de documents à partir de modèles
Il est possible de créer des formulaires permettant aux utilisateurs de n’avoir à saisir que les informations à forte
valeur ajoutée d’un document et de laisser le portail générer les documents en les complétant avec les données
pouvant être automatisées.
Ces documents pourraient aussi bien être des documents textes que des feuilles de calcul, des organigrammes, des
tableaux, des diagrammes et autres courbes.
2.23.1 Sécurité
Plone est reconnu pour le souci de la sécurité qui fait parti de son design initial. Il a été choisi par la CIA, le FBI,
le ministère français de la défense pour cette raison.
20
Chapitre 2. Présentation de Plone
Plone pour les intégrateurs, Version 1.0.0
2.23.2 Montée en charge
Plone fournit des mécanismes de dimensionnement permettant de déployer plusieurs processus sur une ou plusieurs machines en fonction des besoins.
Il est également possible d’utiliser un proxy cache permettant de limiter la sollicitation du serveur.
F IG . 2.17 – Exemple d’architecture de déploiement pour un site conséquent
2.23.3 Serveur virtuel GNU/Linux vs Serveur W2K8
Plone est compatible avec Windows 2008 mais nous lui préférons GNU/Linux en raison de la puissance du scripting shell qui permet de réaliser simplement et à moindre frais l’intégration de composants complexes.
Avec GNU/Linux, il est possible de réaliser des montages vidéos, photos, ou gérer de la génération de documents
sans interface graphique, ce qui permet par exemple de réaliser des conversions de vidéos avec incrustation et
watermarking avec pour seul investissement celui d’une formation.
2.23.4 Tests Unitaires, tests d’intégrations, tests fonctionnels
La communauté assure un haut niveau de qualité en automatisant les tests unitaires qui vérifient le bon fonctionnement du code, les tests d’intégration quant à eux permettent de tester que les différents composants n’entrent
pas en conflit.
Les tests de validation vérifient que les fonctionnalités continuent de fonctionner comme prévu.
Pour les tests de validation nous enregistrons des scénarios d’utilisation avec des outils comme Selenium.
Ainsi nous pouvons les rejouer à chaque changement, ce qui permet de détecter les effets de bord.
2.23.5 Besoin de formation / Transfert technique
L’ensemble des développements, fichiers de configuration, sont réalisés sous licence compatible GPL.
Nos supports de cours sont reversés à la communauté Plone sous licence Creative-Common Share Alike By, ils
sont donc librement téléchargeables et peuvent être partagés, modifiés tant qu’à votre tour vous redistribuez vos
améliorations sous les même termes de licence.
Des tutoriels en ligne peuvent être installés (produit Amberjack). Ces tutoriels permettent de réaliser sous forme
d’exercices les étapes fondamentales à la création et à la publication de document.
2.23. Génération de documents à partir de modèles
21
Plone pour les intégrateurs, Version 1.0.0
2.23.6 Sécurisation
La sécurité de Plone passe par l’utilisation du protocole ssl et vous devez donc acheter un certificat X509 auprès
d’une autorité reconnue par vos navigateurs internet ou en générer un autosigné.
2.23.7 Statistiques
Les rapports sur la fréquentation sont donnés par des outils libres complémentaires tels que webalizer, ou fournissant les même services que Google Analytics pour les sites web.
Par exemple avec piwik nous retrouvons toutes la richesse d’Analytics ce qui vous permet de définir nos propres
statistiques.
Piwik possède en plus l’avantage de pouvoir tenir compte des pages servies par les caches.
Ceci est rendu possible par l’utilisation d’un script javascript exécuté par le navigateur chaque fois qu’une page
du portail est affichée.
F IG . 2.18 – Statistiques avec Piwik
22
Chapitre 2. Présentation de Plone
CHAPITRE 3
Les nouveautés de Plone 3
Présentation des nouveautés de Plone 3 par rapport à Plone 2.5.
–
–
–
–
–
–
–
–
–
–
–
–
–
Édition en ligne
Validation des champs via AJAX
Support des copies de travail
Vérification de l’intégrité des liens
Verrouillage d’un document lors de l’édition
Nouvel onglet partage
Versionnement des documents
Visualiser un document en mode diaporama
Navigation Précédent/Suivant dans un dossier
Générer une table des matières pour un document
Indexage des documents Word et PDF
Mais aussi
Et pour le développeur
3.1 Édition en ligne
Description de la fonctionnalité “Inline editing”
Désactivé par défaut dans Plone 3.3. Pour l’activer, cochez “Activer l’édition en ligne” dans “Configuration du site
-> Site”
3.2 Validation des champs via AJAX
La validation d’un champ d’un formulaire se fait dès que vous le quittez.
3.3 Support des copies de travail
Working Copy support
Installez le produit “Support des copies de travail (Iterate)” via “Configuration du site -> Produits d’extension”.
Vous avez maintenant une nouvelle action “Créer un brouillon” accessible sur n’importe quel contenu.
23
Plone pour les intégrateurs, Version 1.0.0
3.4 Vérification de l’intégrité des liens
Link and reference integrity checking
Lors de la suppression d’une image, Plone regarde si des documents sont en train de l’utiliser pour éviter de casser
des liens.
3.5 Verrouillage d’un document lors de l’édition
Automatic locking and unlocking
Le document est verrouillé lorsque vous l’éditez. Cela permet d’éviter à un autre utilisateur d’éditer en même
temps et d’écraser votre travail.
Le verrouillage a été amélioré dans Plone 3.3. Le verrouillage n’est actif que 10 minutes, reconductible si l’utilisateur est toujours en train de l’éditer.
3.6 Nouvel onglet partage
Easy collaboration and sharing
L’onglet partage a été amélioré, plus simple d’utilisation. Chaque intitulé des colonnes correspond à un rôle.
– Peut Ajouter : Contributor
– Peut modifier : Editor
– Peut voir : Reader
– Peut Modérer : Reviewer
3.7 Versionnement des documents
Versioning, history and reverting content
Vous pouvez activer le versionnement d’un type de contenu à partir de “Configuration du site -> Types”.
Pour pouvoir visualiser les différences entre deux versions, il faut ajouter le type de contenu dans portal_diff.
3.8 Visualiser un document en mode diaporama
Presentation mode for content
Éditez le document et allez dans Paramètres pour cocher “Mode présentation”.
3.9 Navigation Précédent/Suivant dans un dossier
Automatic previous/next navigation
À partir d’un document d’un dossier, vous avez la possibilité d’ouvrir le document précédent ou le suivant.
Éditez le dossier et allez dans Paramètres pour cocher “Activer la navigation ‘précédent/suivant”’.
24
Chapitre 3. Les nouveautés de Plone 3
Plone pour les intégrateurs, Version 1.0.0
3.10 Générer une table des matières pour un document
Auto-generated tables of contents
Éditez le document et allez dans Paramètres pour cocher “Table des matières”.
3.11 Indexage des documents Word et PDF
Full-text indexing of Word and PDF documents
Plone indexe le texte des documents Word et PDF. Il est donc ensuite possible de rechercher un terme qui est dans
ces documents.
Cette fonctionnalité est active si vous avez les packages Ubuntu wv (pour les documents Word) et poppler-utils
(pour la commande pdftotext) d’installés. Voir howto
D’autres formats peuvent être indexés avec le produit ARFilePreview, qui nécessite AROfficeTransforms ou le
nouveau plone.transforms.
– ARFilePreview-v2 branch (2.3.0) fonctionne avec AROfficeTransforms (utilise portal_transforms).
– ARFilePreview trunk v3 fonctionne avec plone.transforms (architecture Zope 3).
3.12 Mais aussi
–
–
–
–
–
–
–
–
–
Éditeur HTML visuel (WYSIWYG) amélioré
Puissantes fonctionnalités de workflow
Gestion flexible de l’authentification
Collections
Support du protocole de moteur de recherche Sitemap
Support de différents formats de balises
Support du wiki
Moteur de règles de contenu pour la gestion d’évènements
Moteur de portlets
En savoir plus : Features in Plone 3
3.13 Et pour le développeur
Technologies qui ont fait leur entrée dans Plone 2.5 et qui sont maintenant incontournables dans Plone 3 :
– profils GenericSetup pour importer/exporter une configuration de site, pour une meilleure industrialisation
– technologies Zope 3 (évènements, vues...), pour une meilleure maintenabilité du code
Technologies qui font leur apparition dans Plone 3 :
– gestion des éléments de page avec les nouvelles viewlets et portlets, pour une meilleure réutilisabilité des développements et une meilleure maintenabilité
3.10. Générer une table des matières pour un document
25
Plone pour les intégrateurs, Version 1.0.0
26
Chapitre 3. Les nouveautés de Plone 3
CHAPITRE 4
Les nouveautés de Plone 4
Présentation des nouveautés de Plone 4 par rapport à Plone 3.3.
Vidéo disponible
–
–
–
–
Performances
Thème
Ergonomie
Amélioration de l’administration du site
– Ordonnancement dans les dossiers amélioré
– Interface améliorée de gestion des groupes
– Tableaux de bord des groupes
– Possibilité de masquer les portlets
– Authentification par email
– Amélioration de la customisation du site
– Gestion des icones d’actions
– Suppression du base_properties
– Améliorations techniques
– Utilisation de Python 2.6 et Zope 2.12
– Gestion des pièces jointes avec les blobs
– Refonte de l’outil de migration
– JQuery Tools de base
– Support de l’indexation des langues asiatiques
– Les dossiers sont tous des BTree
– Migration de Plone 3.3 vers Plone 4
4.1 Performances
Plone 4 est centrée sur l’amélioration des performances. Il est en environ deux fois plus rapide que Plone 3, et
jusqu’à quatre fois plus rapide que Plone 2.5 aussi bien pour les anonymes que pour les utilisateurs connectés. Il
consomme beaucoup moins de mémoire que les anciennes versions. Plone 4 est, à la date de sa sortie l’une des
plateformes open source CMS les plus rapides du marché.
Cela est dû à la fois à un effort majeur sur l’optimisation du code de Plone, qu’au passage à Python 2.6 plus rapide
et moins gourmand que Python 2.4.
En savoir plus (fr)
27
Plone pour les intégrateurs, Version 1.0.0
4.2 Thème
Plone 4 possède un nouveau thème par défaut appelé “Sunburst”, élégant et, minimaliste. Il est conçu comme un
composant à part, mais inclus par défaut. Il est donc facile à remplacer.
Il n’utilise plus de tableaux. La css a été très fortement simplifiée. Il reste compatible avec Internet Explorer 6.
Il est prévu pour être compatible avec le futur outil de mise en page Deco prévu pour Plone 5.
En savoir plus (en)
4.3 Ergonomie
L’interface utilisateur de Plone 4 a été améliorée.
Il est plus facile de créer une site Plone , via une page dédié.
Plone 4 inclut par défaut un nouvel éditeur wysiwyg (TinyMCE), et offre de nouveaux paramètres de configuration.
TinyMCE remplace kupu. Il existe un produit en remplacement de l’éditeur complet FCKeditor : ckeditor.
En savoir plus (en)
Amélioration du formulaire de recherche : les options non pertinentes ont été retirées, les critères sont choisis par
un système de plié/déplié beaucoup plus clair.
En savoir plus (en)
4.4 Amélioration de l’administration du site
4.4.1 Ordonnancement dans les dossiers amélioré
L’interface pour ordonner les documents dans les dossiers a été améliorée. L’intégration entre ‘tri’ et ‘ordonnancement’ a été améliorée.
28
Chapitre 4. Les nouveautés de Plone 4
Plone pour les intégrateurs, Version 1.0.0
4.4.2 Interface améliorée de gestion des groupes
L’interface a été améliorée pour chercher des groupes, associer des utilisateurs à des groupes, etc.
Plone 4 permet de mieux gérer les groupes imbriqués. Dans Plone 3.3, vous ne voyiez pas que vous aviez un
rôle récupéré grâce un super groupe. Plone 4 a été modifié pour le voir, un peu comme la présentation faite dans
l’onglet partage pour les rôles locaux.
En savoir plus (en)
4.4.3 Tableaux de bord des groupes
Il est maintenant possible de paramétrer des tableaux de bord par défaut pour tous les utilisateurs d’un groupe.
En savoir plus (en)
4.4.4 Possibilité de masquer les portlets
Un simple clic dans l’outil de management des portlets permet de masquer/afficher un portlet.
4.4.5 Authentification par email
Plone 4 prévoit la possibilité d’autoriser l’authentification de l’utilisateur par son email plutôt que par son login.
4.5 Amélioration de la customisation du site
4.5.1 Gestion des icones d’actions
Les icones d’actions ne sont plus gérées séparément des actions (disparition du tool portal_actionicons)
4.5.2 Suppression du base_properties
Les css ne sont plus écrites en dtml, mais en texte pur. L’expérience d’utilisation a montré que l’utilisation de
variables dans les css posait plus de risques qu’elle ne faisait gagner de temps.
4.6 Améliorations techniques
4.6.1 Utilisation de Python 2.6 et Zope 2.12
Plone 2.5 et 3.x fonctionnaient sous Python 2.4. Python 2.6 est plus rapide et beaucoup moins gourmand en
mémoire.
Zope 2.12 est compatible avec la version 2.9.x de la ZODB supportant nativement les blobs. Totalement eggifié,
il est plus facile à déployer.
En savoir plus (en)
En savoir plus (en)
4.5. Amélioration de la customisation du site
29
Plone pour les intégrateurs, Version 1.0.0
4.6.2 Gestion des pièces jointes avec les blobs
La ZODB gère maintenant les pièces jointes (images et fichier) de Plone dans des fichiers à part de la Data.fs,
appelés “blobs”.
Cela limite l’impact des modifications de pièces jointes sur la taille des transactions : la zodb est plus rapide et
grossit moins rapidement entre chaque pack.
En savoir plus (en)
4.6.3 Refonte de l’outil de migration
Plone utilise maintenant Generic Setup comme outil de migration. On a maintenant le même système de mise à
jour pour les modules tierces et pour Plone lui-même.
En savoir plus (en)
4.6.4 JQuery Tools de base
La bibliothèque Javascript JQuery Tools est inclus de base. Cela permet d’avoir des popups améliorants l’expérience utilisateur.
En savoir plus (en)
4.6.5 Support de l’indexation des langues asiatiques
Le moteur d’indexation plain texte gère maintenant les langues asiatiques (Chinois, Japonais, Coréen).
En savoir plus (en)
4.6.6 Les dossiers sont tous des BTree
Il y avait auparavant deux types de dossiers : Folder et Large Folder, les seconds étant des BTree. Les Folder sont
maintenant des BTree et les Large Folder ont été retirés.
En savoir plus (en)
4.7 Migration de Plone 3.3 vers Plone 4
Plone 4 apporte quelques changements radicaux. Il vous faudra sans doute adapter le code de vos produits. Il existe
une documentation pour vous y aider.
30
Chapitre 4. Les nouveautés de Plone 4
CHAPITRE 5
Paramétrer votre site Plone
Author Thomas Desvenain
Created 2010-10-18
Version 0.1.0
Révision https ://svn.plone.org/svn/collective/collective.trainingmanual/trunk/fr/integrateur/source/presentation_plone.txt
Copyright (C) 2010 Thomas Desvenain <thomas.desvenain AT gmail.com>.
Chacun est autorisé à copier, distribuer et/ou modifier ce document suivant les termes de la licence
Paternité-Pas d’Utilisation Commerciale-Partage des Conditions Initiales à l’Identique 2.0 France accessible à
http ://creativecommons.org/licenses/by-nc-sa/2.0/fr
5.1 Objectif
Nous allons présenter ici les options de paramétrage offertes de base à l’administrateur d’un site Plone.
5.2 Accéder au menu de configuration
Vous devez être connecté avec un administrateur. Pour accéder au menu de configuration, cliquez sur votre nom
d’utilisateur, par défaut en haut à droite du site,
Vous arrivez sur le menu de configuration du site.
Cette page est composée de trois parties :
– la partie supérieure, Configuration générale, contient des liens vers les différents menus de configuration de
Plone,
– la partie centrale contient les liens vers les menus de configuration ajoutés par les modules complémentaires
que vous aurez installés,
– la partie inférieure contient les informations de version et de debug.
31
Plone pour les intégrateurs, Version 1.0.0
5.3 Configurer les paramètres de messagerie
Si vous arrivez sur cette page la première fois, un message vous alerte sur le fait que vous n’avez pas configuré le
serveur smtp. Nous allons commencer par remédier à cela.
Plusieurs fonctionnalités de Plone provoquent des envois de mail. Pour un bon fonctionnement de votre site, vous
devez configurer la messagerie.
Cliquez sur Envoi de courriels.
Vous arrivez sur la page des Paramètres d’envoi des courriels.
32
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.3. Configurer les paramètres de messagerie
33
Plone pour les intégrateurs, Version 1.0.0
Entrez dans le champ ‘Serveur SMTP’ l’addresse de votre serveur d’envoi. Si vous êtes dans le réseau d’une
entreprise, contactez l’administrateur système pour connaitre ce nom. Si vous êtes à votre domicile, ce nom se
trouve dans le courrier d’ouverture de votre ligne envoyé par votre fournisseur d’accès internet (FAI). Il s’agit en
général de smtp.nomdufai.fr ou smtp.nomdufai.com.
Si vous utilisez Extended-SMTP, remplissez les champs login-mot de passe suivants. À défaut ou si vous n’êtes
pas sûr, ne les remplissez pas.
Les deux derniers champs, obligatoires, indiquent les informations de l’émetteur des mails envoyés par le site
(champ From).
Cliquez sur Enregistrer pour sauvegarder vos modifications.
5.4 Paramètres du site
La page Paramètres du site permet d’éditer les métadonnées du site, et des réglages de référencement (utiles
principalement si votre site est un site internet)
Notamment :
– le tite du site,
– sa description dans les résultats du moteur de recherche
34
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
Exposer les métadonnées Dublin Core : si cette option est activée, chaque page du site aura des metatags dont le
contenu correspondra aux métadonnées du document affiché.
Exposer sitemap.xml.gz : activé, les moteurs de recherche auront accès au sitemap, optimisant l’indexation (activez
l’option, puis allez sur sitemap.xml.gz depuis la racine de votre site).
5.5 Paramètres de base de la sécurité du site
La sécurité dans Plone est un vaste sujet, qui sera traité principalement dans d’autres chapitres sur les workflows,
les rôles et permissions, etc.
Un certain nombre d’options sont disponibles depuis le lien Sécurité de la configuration du site.
5.5.1 Auto-inscription
Si l’option est choisie, une option S’inscrire apparaît dans la zone de login pour les anonymes.
5.5.2 Mot de passe choisi par l’utilisateur
Si cette option est activée, lorsqu’un utilisateur est créé un mot de passe provisoire est envoyé au nouvel inscrit,
qui peut le modifier immédiatement.
5.5. Paramètres de base de la sécurité du site
35
Plone pour les intégrateurs, Version 1.0.0
5.5.3 Activer les dossiers de l’utilisateur
L’option ajoute un lien dossier personnel dans le menu de l’utilisateur.
Il s’agit d’un dossier qui est administré par l’utilisateur, dans lequel il peut ajouter des documents qu’il peut
soumettre à publication.
5.5.4 Affichage de la ligne d’information du document pour les anonymes
Par défaut, seuls les membres voient la ligne de métadonnées Par xxx — Dernière modification xxx sous le titre
des documents. Si cette option est activée, elle est visible par les anonymes.
36
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.5.5 Connexion par email
Permet aux utilisateurs de se connecter en utilisant leur email à la place de leur login.
5.6 Paramétrage du calendrier
Le calendrier de Plone affiche, dans une portlet, un petit calendrier dans lequel les dates comprenant des événements apparaissent en surbrillance.
Nous allons d’abord ajouter une portlet calendrier sur notre site, en haut à gauche.
5.6.1 Ajouter un calendrier
Rendez-vous à la racine de votre site, en cliquant sur le logo. En bas à gauche de la page, cliquez sur Gérer les
portlets
Vous arrivez sur la page de gestion des portlets.
Cliquez sur Ajouter un portlet... sur la colonne de gauche, et sélectionnez la portlet calendrier.
Cliquez sur la flèche-haut devant Calendrier pour monter le calendrier au-dessus de la navigation.
Revenez sur l’accueil. Vous avez maintenant votre portlet calendrier.
Il est bien vide pour le moment...
5.6.2 Compléter le calendrier
Le calendrier contient des références à des contenus événement.
Allez dans le dossier Événements et ajoutez-en un.
Pour l’instant, rien n’a changé. Publiez-le. Il apparait dans le calendrier.
Créez un autre événement pour la veille du précédent, Préparation de la salle, et enregistrez-le, cette fois sans le
publier.
Vous voudriez peut-être que les événements ‘privés’ s’affichent pour leurs propriétaires et tous ceux qui y ont
accès. Il est possible de configurer cela.
5.6. Paramétrage du calendrier
37
Plone pour les intégrateurs, Version 1.0.0
38
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.6. Paramétrage du calendrier
39
Plone pour les intégrateurs, Version 1.0.0
40
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.6. Paramétrage du calendrier
41
Plone pour les intégrateurs, Version 1.0.0
5.6.3 Configurer le calendrier
Retournez dans la Configuration du site, puis cliquez sur Calendrier
Vous pouvez ici sélectionner les états dans lesquels vos événements apparaîtront dans le calendrier.
Sélectionnez Privé [private].
En France, la norme est plutôt de commencer la semaine par le lundi. Sélectionnez Lundi
Enregistrez.
Le document privé apparaît (ici le 18) et l’ordre des jours a changé.
5.7 Paramétrage de la navigation
La page Paramètres de navigation permet de configurer deux choses : les onglets généraux du site et la portlet de
navigation.
42
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.7.1 Configuration des onglets
Par défaut, la barre de navigation supérieure affiche un onglet pour chaque dossier ajouté à la racine.
La première option permet de désactiver ce comportement. (Dans ce cas, il faudra ajouter manuellement les actions
sur la barre d’onglet, ce qui est plus complexe et fera l’objet d’un autre chapitre)
Si la seconde option est activée, les documents de la racine seront également affichés comme onglets.
Si vous voulez masquer un dossier des onglets (par exemple : Membres), rendez-vous sur le dossier, cliquez sur
Modifier, puis Paramètres.
Cochez Exclure de la navigation et enregistrez.
Membres n’apparaît plus dans la barre de navigation supérieure.
5.7.2 Configuration de la navigation
Vous pouvez également choisir ici les types de contenus affichés dans la portlet de navigation. Il est fréquent de
choisir de n’afficher que les dossiers.
Vous pouvez également filtrer les contenus affichés dans l’arborescence par état documentaire (sachant que, de
toute façon, seuls les dossiers et documents qu’un utilisateur a le droit de voir apparaissent dans la navigation)
Le plan du site utilise également ces paramètres.
5.7.3 Configuration de la portlet de navigation
Attention, ces paramètres ne recouvrent qu’une partie de la configuration de la portlet de navigation. Pour la
configurer, revenez à la racine et cliquez sur Gérer les portlets à gauche.
Cliquez maintenant sur le nom de la portlet Navigation.
Vous arrivez sur un menu de configuration (assez complexe) où vous définissez essentiellement trois choses :
– le niveau d’affichage, qui est le nombre de niveaux à partir du niveau racine avant qu’on affiche les contenus
dans la navigation
– le niveau racine, qui est le niveau à partir duquel on compte le niveau d’affichage
5.7. Paramétrage de la navigation
43
Plone pour les intégrateurs, Version 1.0.0
44
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.7. Paramétrage de la navigation
45
Plone pour les intégrateurs, Version 1.0.0
46
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
– la profondeur d’affichage, qui est le nombre de niveaux maximal qu’on affiche sous le niveau racine...
Par défaut, le niveau d’affichage est 1 et le niveau racine est la racine du site : on ne voit donc que les documents
contenus dans les dossiers ajoutés à la racine... (les choses sont paramétrées par défaut de cette façon de sorte que
les dossiers à la racine n’apparaissent pas ET dans la portlet de navigation ET dans la barre d’onglets)
Imaginons que nous voulions afficher les dossiers à la racine. Entrez 0 pour niveau d’affichage et enregistrez.
5.7.4 Conclusion
Pourquoi deux pages pour configurer la portlet de navigation : dans les paramètres du site et dans les paramètres
de la portlet ? En fait, vous pouvez tout à fait avoir plusieurs portlets de navigation sur votre site, configurées
différemment. Mais toutes sont concernées par les paramètres définis au niveau de la configuration du site...
5.8 Paramètres de la recherche
La page Paramètres de la recherche permet :
– D’activer / désactiver la recherche instantanée,
– De sélectionner les types de contenu dans lesquels on fait nos recherches,
Et de décider finement d’activer ou pas certaines options de recherche de la recherche avancée :
– possibilité de chercher par état pour les anonymes,
– possibilité de modifier l’ordre des résultats,
– possibilité de modifier le nombre de résultats par page,
– champs de recherche spécifiques Titre et Description,
– réduction automatique des options rarement utilisées.
5.8. Paramètres de la recherche
47
Plone pour les intégrateurs, Version 1.0.0
48
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.8. Paramètres de la recherche
49
Plone pour les intégrateurs, Version 1.0.0
50
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.9 Configurer le thème
Cette page permet de configurer les paramètres d’apparence, notamment le thème sélectionné.
Amusez-vous à sélectionner le Plone Classic Theme
Il permet de s’assurer que Plone 4 est toujours compatible avec les thèmes conçus pour les anciennes versions...
Ceci étant dit, vous pouvez revenir sur le thème de Plone 4 (Sunburst) :)
Vous pouvez paramétrer les liens externes de sorte qu’ils soient marqués,
et qu’ils s’ouvrent dans un nouvel onglet.
Vous pouvez également supprimer les icônes de type de contenu dans les listes et les portlets.
Enfin, vous pouvez désactiver le système de popup en superposition (dit aussi lightbox) pour les formulaires
simples.
5.10 Paramétrage des modules
Pour l’activation et la désactivation de modules, référez-vous au chapitre Choix et ajout d’un module.
5.11 Paramétrage des règles de contenu
Pour les règles de contenu, référez-vous au chapitre Déclenchement d’événements avec les règles de contenu.
5.9. Configurer le thème
51
Plone pour les intégrateurs, Version 1.0.0
52
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.12 Paramétrer l’édition de contenus
La page des Paramètres d’édition permet de configurer le comportement général de l’édition de documents.
5.12.1 Edition de l’identifiant
Chaque contenu a un identifiant, qui est unique dans chaque dossier. Par défaut, l’identifiant est généré automatiquement à partir du titre proposé. Vu que l’identifiant est utilisé dans l’URL, de nombreux utilisateurs préfèrent le
saisir eux mêmes.
Avec cette option activée, les utilisateurs auront une nouvelle option dans leurs préférences personnelles :
Si elle est activée, l’utilisateur pourra saisir l’identifiant d’un document lorsqu’il le crée ou le modifie.
5.12. Paramétrer l’édition de contenus
53
Plone pour les intégrateurs, Version 1.0.0
5.12.2 Éditeur de texte par défaut
Par défaut sur Plone, l’éditeur de texte est TinyMCE. Cependant il est possible d’installer d’autres éditeurs (ckeditor notamment).
Chaque utilisateur peut choisir son éditeur, mais par défaut, l’éditeur sera celui choisi sur cette page de configuration.
Si vous avez installé un nouvel éditeur sur votre site, ckeditor par exemple, il aura une page de configuration
spéciale, avec un lien ajouté dans la partie Configuration de module du menu de configuration.
5.12.3 Éditeur externe
Si cette option est activée, les utilisateurs auront la possibilité d’activer l’édition externe dans leurs préférences
personnelles.
L’édition externe permet, à condition d’avoir installé un soft sur son poste, de modifier des documents de Plone
en les éditant directement avec son logiciel préféré, sans avoir besoin de passer par un formulaire. Ce qui est
particulièrement utile pour les fichiers type tableur ou traitement de texte.
Veuillez vous référer au chapitre Zope External Editor pour de plus amples informations.
54
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.12.4 Édition en ligne
À ne pas confondre avec l’édition externe, l’édition en ligne permet de modifier les documents en saissant directement vos données en cliquant sur la vue d’affichage, sans passer par un formulaire de modification.
Par exemple, ici nous modifions ‘en ligne’ la description de la page d’accueil du site.
Attention, cette option ralentit considérablement les performances sur les anciens navigateurs (IE 6...).
Sur les navigateurs les plus récents, elle est par contre insensible.
5.12.5 Vérification de l’intégrité des liens
Si cette option est activée, lorsque vous supprimez un document, Plone vérifie qu’aucun autre document ne
contient un lien vers ce document, et vous alerte le cas échéant.
Nous avons créé un document Mon document de référence et un document Mon document contenant des liens.
Dans ce dernier, nous avons ajouté un lien, dans le texte principal, avec le premier.
Quand nous supprimons Mon document de référence nous obtenons cette popup de confirmation :
5.12.6 Verrouillage des documents en modification
Quand le verrouillage est activé, si un utilisateur est sur le formulaire de modification d’un document, les autres
utilisateurs susceptibles de modifier le document sont avertis, et ils ne peuvent accéder au formulaire sans forcer
le déverrouillage.
5.13 Paramétrer le filtrage du contenu ajouté en HTML
Les éditeurs WYSIWIG permettent aux contributeurs du site d’éditer le code html de pages qui seront ensuite
affichées par les navigateurs des visiteurs du site.
5.13. Paramétrer le filtrage du contenu ajouté en HTML
55
Plone pour les intégrateurs, Version 1.0.0
56
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.13. Paramétrer le filtrage du contenu ajouté en HTML
57
Plone pour les intégrateurs, Version 1.0.0
Il peut être dangereux ou gênant de permettre à vos utilisateurs de créer des formulaires, d’afficher des objets flash
ou autre, d’ajouter des balises meta, de trop paramétrer le style de son contenu, etc.
La page Paramètres du filtrage HTML permet à l’administrateur du site de contrôler les éléments html dont il
permet l’introduction par les contributeurs.
Dans l’autre sens, si vos utilisateurs s’étonnent que certains contenus qu’ils ajoutent ne sont pas enregistrés, c’est
ici que vous pouvez étendre les autorisations.
La première page permet de définir les balises qui sont filtrées.
5.13.1 Filtrage des balises
Par défaut, toutes les balises XHTML sont acceptées, les autres sont filtrées : l’élément est supprimé mais pas son
contenu.
Éditez un document du site avec un éditeur WYSIWYG, mais avec l’option HTML (éditer le code source). Entrez
le contenu
<toto>Ceci est du texte dans une balise non-html</toto>
Enregistrez le document. Éditez-le à nouveau. Le texte ci-dessus a été remplacé par du XHTML valide, par
exemple avec TinyMCE
<p>Ceci est du texte dans une balise non-html</p>
5.13.2 Balises indésirables
Ajoutez maintenant ce code
<script language="Javascript">while(0!=1) alert(’toto’);</script>
Enregistrez. Heureusement, ce script ne s’applique pas ! Rééditez votre page sur l’édition, et cliquez sur ‘HTML’.
Vous verrez que votre code a été remplacé par
<!-- while(0!=1) alert(’toto’); // -->
Les balises indésirables sont commentées. Là donc, même le contenu n’apparaît pas.
5.13.3 Balises non-XHTML autorisées
Le troisième bloc de la page permet d’autoriser dans le html des balises qui ne sont pas XHTML. On y trouve
notamment les balises HTML5.
5.13.4 Filtrage des attributs
La deuxième page permet de filtrer les attributs.
Le premier bloc indique la liste des attributs qui seront simplement supprimés à l’enregistrement.
Le second bloc indique les attributs qui seront supprimés s’ils sont dans telle ou telle balise en particulier. Par
exemple, ici on retire les attributs width et weight des tables et des cellules.
58
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.13. Paramétrer le filtrage du contenu ajouté en HTML
59
Plone pour les intégrateurs, Version 1.0.0
60
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.13.5 Filtrage des styles et des classes
Si l’attribut style est autorisé, vous ne voulez pas forcément que vos utilisateurs puissent attribuer n’importe quelle
valeur css.
De même, vous craignez peut-être que vos utilisateurs utilisent certaines classes css.
Vous pouvez maitriser la liste des attributs css disponibles dans les attributs ‘styles’, ainsi que les noms de classes
interdits dans toute balise ‘class’.
Editez votre document, et entrez ce code
<p style="font-size: 250px; text-align: right">Mon texte stylé</p>
Vous observez que seul le text-align s’applique. Éditez à nouveau le contenu, vous verrez que ce code est conservé
<p style="text-align: right; ">Mon texte stylé</p>
5.14 Paramétrer le comportement wiki
5.14.1 Activer le comportement wiki
Plone permet d’avoir un comportement wiki, afin d’optimiser la création de contenus liés.
Par défaut, cela n’est pas activé. Allez dans Paramètres du formatage de texte.
5.14. Paramétrer le comportement wiki
61
Plone pour les intégrateurs, Version 1.0.0
Puis allez sur l’onglet Comportement wiki.
Nous allons l’activer pour les documents. Cochez Documents et enregistrez.
5.14.2 Se servir de Plone comme d’un Wiki
Créez maintenant un document sur votre site. Mettez entre double-parenthèses (( )) ou entre double-crochets [[ ]]
les documents que vous voulez pouvoir lier par la suite.
Un clic sur un lien ‘+’ crée un nouveau contenu ayant pour titre le texte lié.
Le lien + se transforme en lien vers le nouveau contenu.
L’identifiant (ici : CMS) peut être utilisé à plusieurs endroits (y compris sur plusieurs pages différentes), il crée
automatiquement un lien vers cette nouvelle page.
5.15 Gestion des tailles d’images
Quand vous ajoutez une image dans un document, vous choisissez parmi un certain nombre de tailles d’images.
Ces tailles disponibles sont éditables dans la configuration du site, dans Paramètres de la gestion des images.
5.16 Maintenance du serveur et de la base
Les opérations de maintenance sont disponibles depuis la page Maintenance du menu de configuration.
Vous pouvez, de cette page, arrêter ou redémarrer le site, et ‘packer’ la base de données.
La base de données (ZODB) doit être packée régulièrement. Elle stocke toutes les transactions effectuées, ce qui
est utile notamment pour la fonction Undo, mais ralentit progressivement les performances en lecture / écriture.
Il est nécessaire de purger ces informations, en conservant celles des derniers jours.
Un chapitre sur la ZODB est à venir dans la documentation développeur.
62
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.16. Maintenance du serveur et de la base
63
Plone pour les intégrateurs, Version 1.0.0
5.17 Choix de la langue du Site
La page Paramètres linguistiques permet de choisir la langue du site. Elle est définie par défaut comme la langue
du navigateur de l’utilisateur qui a créé le site.
Les options de langue pour les sites multilingues ne se configurent pas ici. Nous fournirons une documentation
spécifique pour les sites en plusieurs langues.
5.18 Paramétrer les collections
Cette page permet de sélectionner les critères disponibles pour les collections, et de les paramétrer, ainsi que les
données disponibles à l’affichage des collections.
Cette page correspond à un paramétrage plus avancée du site, nous y reviendrons dans un chapitre dédié aux
collections.
5.19 Paramétrer les types de contenu
5.19.1 Définir le workflow par défaut
Première page : workflow par défaut.
Changer le workflow :
Enregistrer :
64
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.19. Paramétrer les types de contenu
65
Plone pour les intégrateurs, Version 1.0.0
66
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.19. Paramétrer les types de contenu
67
Plone pour les intégrateurs, Version 1.0.0
68
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.19.2 Définir le workflow de chaque type
Sélectionner un type. On peut choisir son workflow spécifique.
5.19.3 Ajout global
Si cette option est activée pour un type, un document de ce type peut être ajouté dans n’importe quel dossier qui
ne comporte pas de restriction sur son contenu.
5.19.4 Politique de versionnement
Activer le versionnement manuel pour les fichiers.
Modifier ensuite un fichier.
Cocher la case nouvelle version.
5.19.5 Autoriser les commentaires
Si cette option est activée, le type de contenu est ouvert au système de commentaires.
Activez les commentaires pour le type Fichier. Allez sur un contenu fichier, vous voyez maintenant une section
Commentaires avec un bouton Ajouter un commentaire.
Si vous cliquez sur Ajouter un commentaire, une popup s’ouvre vous permettant de saisir votre texte.
Enregistrez-le, il apparaît au bas du document. Il est possible de le supprimer, ou d’y répondre.
5.19.6 Portlets spécifiques du type de contenu
Vous pouvez paramétrer des portlets qui s’afficheront suivant le type de contenu de la page affichée.
Sélectionnez un type de contenu (ici Fichier) sur l’écran de configuration des types. Vous avez un lien Gérer les
portlets affectés à ce type de contenu.
Cliquez ce lien, vous arrivez sur une page similaire à la page Gérer les portlets vue plus haut.
Ajoutez une portlet, en naviguant sur le site, vous verrez que lorsque vous allez sur une page Fichier, cette portlet
apparaît.
5.19. Paramétrer les types de contenu
69
Plone pour les intégrateurs, Version 1.0.0
70
Chapitre 5. Paramétrer votre site Plone
Plone pour les intégrateurs, Version 1.0.0
5.19. Paramétrer les types de contenu
71
Plone pour les intégrateurs, Version 1.0.0
72
Chapitre 5. Paramétrer votre site Plone
CHAPITRE 6
Choix et ajout d’un module
Author Michael Launay
Version 0.1.0
Révision https ://svn.plone.org/svn/collective/collective.trainingmanual/trunk/fr/integrateur/source/choix_et_ajout_d_un_mo
Copyright (C) 2010 Michael Launay <michaellaunay AT ecreall.com>.
Chacun est autorisé à copier, distribuer et/ou modifier ce document suivant les termes de la licence
Paternité-Pas d’Utilisation Commerciale-Partage des Conditions Initiales à l’Identique 2.0 France accessible à
http ://creativecommons.org/licenses/by-nc-sa/2.0/fr
6.1 Introduction
Plone est un Content Management System, c’est à dire un portail collaboratif qui permet de gérer des contenus
tels que des documents, des images, des événements, des vidéos, etc.
Il permet de créer et de gérer les cycles de publications des contenus, ainsi on peut affecter des rôles aux membres
leur permettant ou non de créer, modifier, voir, ou changer les règles des contenus.
Plone permet facilement la création de nouveaux types de contenu, de nouvelles règles de gestion, de nouveaux
rôles ou groupes.
Cette finesse de la gestion des droits associée au fait que Plone est un logiciel libre a permis la création de
nombreuses extensions permettant soit de spécialiser Plone soit de l’étendre.
Ces extensions ont d’abord été appelées “produits” mais à partir de la version 4 de Plone nous parlons de “modules”.
La première étape consiste à identifier son besoin.
Ensuite, il faut vérifier que Plone ne propose pas déjà les fonctionnalités désirées.
Pour cela, nous pouvons commencer par voir si Plone fournit de base un type de contenu spécifique de ce besoin.
S’il existe un contenu, il faut alors vérifier que le workflow, qui lui est associé, correspond à notre besoin et si
nécessaire en développer un autre.
S’il n’existe pas de contenu correspondant à notre besoin et que celui-ci est générique, alors il existe surement un
module couvrant partiellement ou complètement notre besoin.
On va donc chercher et sélectionner un module.
73
Plone pour les intégrateurs, Version 1.0.0
6.2 Rechercher et sélectionner un module
Le site plone.org contient la vitrine des modules Plone disponibles.
http ://plone.org/products
Depuis la version 4 de Plone le site de la communauté Plone possède un nouveau classement des modules qui
permet entre autres de les chercher par popularité.
Un article sur cette nouvelle interface a été écrit sur le site de la communauté française
http ://plone.fr/news/nouveautes-plone-products
Les modules suivent un cycle de vie de développement, les plus utilisés sont maintenus et sont adaptés aux nouvelles versions de Plone rapidement.
Avant d’utiliser un module, il faut se poser les questions suivantes :
– Ce module est-il compatible avec notre version de Plone ?
– Depuis combien de temps existe le module ?
– Est-il encore utilisé ?
– Est-il maintenu ?
– Y a-t-il eu des remontées de bogues et est-ce possible ?
– Si oui y a-t-il eu des corrections apportées et au bout de combien de temps ?
– La société ou les développeurs derrière ce module, sont-ils actifs dans la communauté ?
– A-t-on accès au code source du module ?
– Le code est-il sur le dépôt de la communauté Python ou Plone ?
– Le module respecte-t-il les standards de programmation de la communauté ?
– Est-il documenté ?
– Modifie-t-il Plone ?
Suivez ensuite la méthode d’installation indiquée sur la documentation du produit. À défaut d’être précisée, c’est
toujours la même, nous la présentons plus loin.
6.3 Installer un module
Les modules Plone proposés sur plone.org sont hébergés sur des dépôts.
– Le dépôt des programmes open source de Python, appelé “pypi” et accessible sur le lien
http ://pypi.python.org/pypi
– Les dépôts des projets et sociétés dont les adresses peuvent être trouvées sur internet.
Le dépôt Pypi est celui de la communauté Python qui est le langage de programmation de Plone. Pour y trouver
un module spécifique de Plone il faut faire une recherche en utilisant le mot-clé Plone et les mots que vous pensez
être associés à votre besoin.
Pypi affichera les “egg” liées à Plone, en effet depuis les versions 3 de Plone les modules sont fournis sous forme de
paquets appelés “egg” dont on détaillera l’anatomie et comment les ajouter à Plone plus loin. Plone est désormais
entièrement constitué de eggs qui forment autant de bibliothèques.
Les modules hébergés exclusivement par les sites de leurs développeurs sont plus durs à identifier et leur capital
confiance est moins bon.
Pour installer un module, il suffit en général d’ajouter le nom du module à la valeur eggs dans le fichier de
configuration (buildout.cfg), et de relancer l’installation du site. (Pour plus d’information sur l’installation de
Plone, consultez la documentation intégrateur).
Il vous faut ensuite aller dans la configuration du site,
74
Chapitre 6. Choix et ajout d’un module
Plone pour les intégrateurs, Version 1.0.0
section Modules,
puis activer le module.
De nombreux exemples d’installation de modules seront présentés dans cette documentation.
6.4 Tester le module
Ensuite il faut absolument essayer le module sur une copie du site de production pour vérifier qu’il correspond à
notre besoin et surtout qu’il ne casse pas nos autres modules et respecte l’intégrité de notre site.
Il faut alors dérouler des tests de validation du portail pour vérifier l’intégrité du portail.
Puis il faut tester le fonctionnement du module pour vérifier son adéquation avec le besoin.
Si le besoin n’est pas complètement satisfait il faut alors chercher un module plus complet ou compléter le développement du module sélectionné.
Le fait de compléter un module déjà existant par rapport à en créer un ex nihilo est à préférer, surtout si les
évolutions que l’on souhaite apporter sont dans la logique du module.
Cette attitude vertueuse permet :
– de réduire les coûts en ne recréant pas ce qui existe déjà,
– de bénéficier d’une communauté d’utilisateurs et de développeurs,
6.4. Tester le module
75
Plone pour les intégrateurs, Version 1.0.0
– d’améliorer la couverture fonctionnelle d’un module ce qui du coup augmente ses chances d’être réutilisé et
donc maintenu.
76
Chapitre 6. Choix et ajout d’un module
CHAPITRE 7
Le protocole HTTP et ses tests
– Définition
– Savoir
– Les versions de HTTP et leur RFC
– L’envoi de requêtes
– Les méthodes (HEAD, GET, POST, DELETE, PUT, CONNECT, OPTIONS, TRACE)
– GET
– HEAD
– POST
– OPTIONS
– CONNECT
– TRACE
– PUT
– DELETE
– L’entête et ses champs (Host, Referer, User-Agent, etc.)
– Host
– Referer
– User-Agent
– Connection
– Accept
– Accept-Charset
– Accept-Language
– La réponse et ses champs
– Date
– Server
– Content-Length
– Content-Type
– Expires
– Last-Modified
– Les cookies
– HTTPS
– Mesures de charges
– Exercice
– Ressources
7.1 Définition
Connaître le protocole HTTP permet d’anticiper certaines limitations de déploiement.
77
Plone pour les intégrateurs, Version 1.0.0
Le protocole HyperText Transfert Protocol est un ensemble de règles qui régit la demande et l’envoi de pages web
entre un client et un serveur.
Le protocole HTTP délègue au protocole TCP (Transmission Control Protocole) l’envoi physique des données.
Les clients sont généralement des navigateurs web qui se connectent via internet à des serveurs Web qui leur
retournent les pages demandées.
Toutefois il existe des applications qui utilisent ce protocole pour communiquer entre elles.
Nous rappelons ce qui se passe généralement lorsqu’un utilisateur demande à son navigateur une page web :
1. L’utilisateur saisit le nom d’un site ou d’une page (adresse URL) dans la barre d’adresse de son navigateur
par exemple http ://www.ecreall.com/societe ;
2. Le navigateur découpe le nom saisi pour extraire le protocole à utiliser, ici http car le préfixe est “http ://”,
et le nom du serveur, ici www.ecreall.com ;
3. Le navigateur réalise alors un résolution de nom en se connectant à un serveur de nom qui lui permettra de
transformer le nom en adresse IP, www.ecreall.com donnera 88.191.227.112 ;
4. Il se connectera alors au serveur via le protocole TCP/IP en se connectant au port 80 qui est celui du protocole http par défaut (il est possible de donner un autre numéro de port par exemple
http ://www.ecreall.com :8080/) ;
5. Si la connexion réussit, le navigateur suivra les règles du protocole http pour demander la page “societe” en
envoyant les requêtes appropriées au serveur ;
6. Le serveur retournera alors cette page au format HTML ou XHTML en utilisant à son tour le protocole
HTTP et fermera la connexion ;
7. Une fois la page reçue, le navigateur analysera son contenu et appliquera les règles html ou xhtml pour
réaliser la mise en forme et afficher le résultat.
7.2 Savoir
7.2.1 Les versions de HTTP et leur RFC
Le protocole HTTP inventé par Tim Berners-Lee en 1989 devient un standard en 1996 et se répand sur internet en
version HTTP/1.0.
Le protocole est décrit par la Request For Comment RFC 1945.
Cette version permet de gérer plusieurs serveur web sur une même machine et donc de servir un contenu différent
en fonction de la racine de l’URL.
En 1997 sort la version HTTP/1.1 modifiée en 1999 et décrite par la RFC 2616, qui ajoute le support du pipeline
(envoi de plusieurs requêtes puis réception de toutes les réponses) et la négociation de type de contenu.
7.2.2 L’envoi de requêtes
Le client se connecte au serveur et lui transmet ses attentes (que l’on appelle méthodes), le serveur lui répond et
se déconnecte. Cet échange s’appelle une requête.
Avant d’arriver au serveur, la requête peut passer par plusieurs intermédiaires qui peuvent la modifier ou y répondre
s’ils connaissent déjà la réponse (mécanisme de la mise en cache).
L’un des grands avantages du protocole http est qu’il s’agit d’un protocole texte. Ainsi un humain peut à l’aide du
programme “telnet” dialoguer avec un serveur en entrant directement le nom des commandes et leurs paramètres.
78
Chapitre 7. Le protocole HTTP et ses tests
Plone pour les intégrateurs, Version 1.0.0
7.2.3 Les méthodes (HEAD, GET, POST, DELETE, PUT, CONNECT, OPTIONS,
TRACE)
GET
Cette méthode permet de demander une ressource telle qu’une page, une image, etc. Elle ne modifie pas la ressource, en conséquence si la ressource n’a pas été modifiée, le résultat de la requête est toujours le même.
HEAD
Cette méthode permet d’obtenir des informations sur une ressource.
POST
Cette méthode permet d’envoyer le résultat d’un formulaire ou de transmettre un fichier vers le serveur. Les
informations à envoyer se trouve dans les données de la requête et non pas dans l’URL.
OPTIONS
Cette méthode permet d’obtenir les options de communication d’une ressource ou du serveur en général.
CONNECT
Cette méthode permet de demander aux intermédiaires de ne pas changer le contenu des requêtes et de les passer
au serveur.
TRACE
Cette méthode demande au serveur de retourner ce qu’il a reçu, ceci pour permettre de diagnostiquer la connexion.
PUT
Cette méthode remplace ou ajoute une ressource sur le serveur si l’on en a les droits.
DELETE
Cette méthode supprime une ressource du serveur si l’on est autorisé à le faire.
7.2.4 L’entête et ses champs (Host, Referer, User-Agent, etc.)
Une requête HTTP 1.0 présente le format suivant :
Ligne de commande (Commande, URL, Version de protocole)
En-tête de requête
[Ligne vide]
Corps de requête
Les réponses HTTP 1.0 présentent le format suivant :
Ligne de statut (Version, Code-réponse, Texte-réponse)
En-tête de réponse
[Ligne vide]
Corps de réponse
7.2. Savoir
79
Plone pour les intégrateurs, Version 1.0.0
Exemple de requête :
GET / HTTP/1.0
Host: www.ecreall.com
User-Agent: Telnet
Nous allons voir ici les principaux champs.
Host
Il permet d’indiquer au serveur le site que l’on souhaite interroger et permet donc le virtualhosting.
Il est obligatoire pour le protocole 1.1.
Referer
Donne l’URI sur laquelle on a trouvé et cliqué le lien menant à la page demandée. Ce champ est utilisé pour les
statistiques.
User-Agent
Donne le nom du programme utilisé pour se connecter au serveur.
Le protocole HTTP/1.1 ajoute les champs suivants :
Connection
Ce champ permet au navigateur ou au serveur de préciser des options de connexion souhaitées ou appliquées.
Le champ Connection ne contient que la liste des options.
La valeur d’une option est alors précisée dans l’entête comme s’il s’agissait d’un champ, toutefois le nom du
champ est le même que celui mis dans Connection.
Accept
Indique les types MIME gérés par le client. L’astérisque est un joker.
Accept-Charset
Donne les encodages de caractères supportés.
Accept-Language
Spécifie les langages acceptés.
7.2.5 La réponse et ses champs
Réponse :
80
Chapitre 7. Le protocole HTTP et ses tests
Plone pour les intégrateurs, Version 1.0.0
HTTP/1.1 200 OK
Date: Fri, 19 Feb 2010 13:22:42 GMT
Server: Zope/(Zope 2.10.6-final, python 2.4.5, linux2) ZServer/1.1 Plone/3.1.7
Content-Length: 16051
Expires: Sat, 01 Jan 2000 00:00:00 GMT
Content-Type: text/html;charset=utf-8
Content-Language: fr
Via: 1.0 www.ecreall.com
Connection: close
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
...
La première ligne est le statut de la réponse :
– 2xx (ici 200), pas de problème.
– 3xx la ressource a été déplacée.
– 4xx la ressource n’existe pas.
– 5xx il y a un problème.
Date
Date de création de la réponse.
Server
Annonce le logiciel et la version ayant crée la réponse.
Content-Length
La taille de la ressource en octets.
Content-Type
Type MIME de la ressource.
Expires
Date de “péremption” de la réponse. Au-delà de cette date la page devra être rechargée ce qui permet au navigateur
ou au cache de savoir quand transmettre les requêtes.
Last-Modified
Date de dernière modification de la ressource.
Autres entêtes HTTP
Ce qui précède est un aperçu des entêtes HTTP les plus courantes. D’autres entêtes peuvent également être échangées entre un navigateur et un serveur, notamment pour la gestion du cache. Pour plus de détails sur la négociation
de cache, lire (en anglais) http ://www.mnot.net/cache_docs/
7.2. Savoir
81
Plone pour les intégrateurs, Version 1.0.0
7.2.6 Les cookies
Le cookie est un ensemble de données transmises dans l’entête des requêtes http par un serveur (Set-Cookie :
name=value) à un client qui les stockes sur son disque s’il est persistant et le retransmet à chaque requête au
serveur (Cookie : name=value).
Il sert soit à l’authentification, soit à la gestion de la session, soit à l’enregistrement des préférences du client etc.
7.2.7 HTTPS
HTTPS est l’encapsulation du protocole http dans une couche de chiffrement telle SSL ou TLS.
Le serveur doit posséder un certificat X509 qui permettra d’une part de vérifier l’authenticité du serveur, et d’autre
part d’échanger confidentiellement avec le client une clé permettant de chiffrer symétriquement la suite de la
communication. En effet, l’une des particularités de ssl est que le serveur possède une clé publique qui sera
envoyée en clair au client, et une clé privée qui permettra de déchiffrer les informations chiffrées avec la clé
publique. Ce chiffrement est dit asymétrique et est complexe et lent à mettre en œuvre mais il présente l’immense
avantage que le client n’a pas à partager de secret avec le serveur avant de se connecter et peut ainsi se connecter
avec des serveurs qu’il ne connait pas.
Le certificat X509 du serveur doit être signé par une autorité connue du client pour que le navigateur fasse
confiance au serveur. Le mécanisme mis en œuvre pour cette signature repose également sur le mécanisme de
chiffrement asymétrique, le client possède une liste d’autorités connues avec leurs clés publiques respectives ce
qui permettra de vérifier qu’un certificat X509 est intègre et a bien été signé par l’autorité indiquée dedans.
De plus le chiffrement symétrique de la communication est associé à une fonction de hachage qui permet d’assurer
l’intégrité des données transmises.
Le port utilisé par HTTPS est par défaut le 443.
7.2.8 Mesures de charges
Pour mesurer la vitesse de réponse de notre serveur, ainsi que sa capacité à supporter plusieurs requêtes simultanées nous allons utiliser deux outils : Firebug et ab.
“firebug” est un plugin de Firefox qui permet d’analyser les pages web et d’en connaître les détails. Son onglet
Réseau permet de voir les ressources chargées, leur temps de chargement, leur taille. L’onglet Réseau/HTML
permet de voir les entêtes des requêtes.
ab est un outil fournit avec Apache qui permet de lancer des requêtes en parallèles afin de contrôler la capacité du
serveur à gérer celle-ci.
Exemple :
$ ab http://www.ecreall.com
$ ab -n 20 -c 4 http://www.ecreall.com/ \
# qui envoie 20 requêtes répartie en 4 threads
Lorsqu’on rencontre des problèmes réseaux difficiles à identifier, il peut être utile d’utiliser tcpdump -i eth0 -w
/tmp/nomdufichier sur le serveur, afin d’enregistrer tous les paquets circulant sur l’interface eth0 dans le fichier
/tmp/nomdufichier. On peut alors utiliser ‘wireshark’ pour inspecter les trames enregistrées dans le fichier.
7.3 Exercice
Utilisation de telnet pour accéder au serveur. Test de performance du serveur (la commande “ab” d’Apache).
82
Chapitre 7. Le protocole HTTP et ses tests
Plone pour les intégrateurs, Version 1.0.0
7.4 Ressources
–
–
–
–
–
Le protocole HTTP
Les cookies
Les certificats électroniques
Autorité de certification
Le modèle OSI
7.4. Ressources
83
Plone pour les intégrateurs, Version 1.0.0
84
Chapitre 7. Le protocole HTTP et ses tests
CHAPITRE 8
Rappel HTML et XML
– Définition
– Comment sont composées les pages internet ?
– Rappel sur les bases HTML et XML
– Savoir
– Les nœuds
– Les éléments
– Les attributs
– Le texte
– Distinction entre HTML et XML
– Le prologue
– Le doctype
– Les DTD et schémas
– Les documents bien formés
– Les documents validés
– Les commentaires
– Les espaces de noms
– Exercices
– Ressources
8.1 Définition
8.1.1 Comment sont composées les pages internet ?
Les pages internet sont de simples documents texte dont certains mots sont interprétés par le navigateur pour
insérer des images, mettre en forme le document comme par exemple créer des titres, proposer des liens, exécuter
des scripts qui sont des suites d’instructions indiquant au navigateur ce qu’il doit faire, etc.
Lorsque on utilise un logiciel produisant du HTML, il ne fait qu’écrire un fichier texte mélangeant notre contenu
avec les éléments du HTML.
8.1.2 Rappel sur les bases HTML et XML
Lorsqu’en 1989 Tim Berners-Lee créait le protocole HTTP, il créait aussi HTML (Hypertext Markup Language)
qui est le format de données transmis par HTTP, il met aussi au point le mécanisme d’URL qui permet de localiser
une ressource sur le web.
Le format HTML est un format texte issu de SGML, dont la volonté est de séparer le fond de la forme.
85
Plone pour les intégrateurs, Version 1.0.0
Il permet de mettre en évidence les parties importantes d’un texte en les balisant. Pour cela, on encadre
le texte avec un élément HTML qui se présente sous la forme <element attribut1="valeur1"
attribut2="valeur2">texte</element>.
Les différentes versions de HTML spécifient les noms des éléments et des attributs possibles.
HTML évolue continuellement, nous sommes à la version 4.1 et la version 5 est à l’étude.
Dès ses origines le langage de balise évolue par l’ajout des différents éditeurs de navigateur web.
Jusqu’en 1992, il n’existe aucune spécification du langage, et par convention on parle de HTML 1.0 pour désigner
ce qui se faisait à l’époque. En 1993, Mosaic apporte les formulaires rendant ainsi le web interactif ainsi que
l’affichage des images.
En 1995 sort la version 2.0 de HTML, proposée par le W3C World Wide Web Consortium qui vient d’être créé.
En 1997 sort la version 3 puis la version 4.0 qui décrit le mécanisme des feuilles de styles CSS (Cascading Style
Sheets). La version 4 est devenue la version la plus utilisée sur le web, les dernières corrections datent de 1999
avec la version 4.1.
XML a fait son apparition en 1998 avec la version 1.0, afin de rendre plus cohérent l’usage des éléments, il
demande que chaque balise ouverte soit fermée, que les attributs aient toujours une valeur entre guillemets. En
2004 sort la version 1.1.
La version 2.0 de XHTML qui devait apporter XForms et XFrames a finalement été abandonnée en décembre
2009. Et HTML 5 a du coup été relancé.
La grande force de XML est la possibilité d’enrichir facilement l’ensemble des balises existantes sans avoir à
modifier les recommandations du w3c, contrairement à HTML.
8.2 Savoir
Nous traiterons en priorité XHTML car c’est le format utilisé par Plone.
8.2.1 Les nœuds
On peut représenter un texte XML ou HTML par une arborescence de nœuds contenant du texte et/ou d’autres
nœuds, cela reviendrait à dire qu’un nœud est l’équivalent d’un répertoire ou d’un fichier en faisant le parallèle
avec une arborescence de fichiers.
8.2.2 Les éléments
Chaque nœud ayant un nom est appelée un élément, il est composé d’une balise ouvrante commençant par un
chevron ouvert < puis d’un nom ne contenant que des lettres, des chiffres ou des tirets bas, de zéro à plusieurs
attributs séparés par des espaces, enfin la balise finie par un chevron fermé >.
Exemple :
<un_element>
bla bla
<un_sous_element />
<un_autre_sous_element>
encore du bla bla
</un_autre_sous_element>
<un_element_avec_un_attribut un_attribut="sa valeur"/>
</un_element>
Un élément doit obligatoirement être fermé soit par une balise portant le même nom mais précédé par / et ne
pouvant contenir aucun attribut, soit par / avant le chevron de fermeture.
86
Chapitre 8. Rappel HTML et XML
Plone pour les intégrateurs, Version 1.0.0
8.2.3 Les attributs
Un attribut est un couple nom-valeur écrit à l’intérieur de la déclaration d’une balise, qui permet de préciser
l’élément qu’il qualifie.
En XML la valeur est entre guillemets et peut être vide “” mais ne peux être nulle.
8.2.4 Le texte
Le texte dans XHTML est contenu par un élément et est en unicode par défaut, le jeu de caractère est celui de
l’UTF-8 ce qui permet de traiter toutes les langues.
8.2.5 Distinction entre HTML et XML
HTML peut être vu comme un XML permissif car il autorise que les balises ne soient pas fermées, qu’une balise
ouvrante soit fermée par une balise dont la casse du nom soit différente de celle ouvrante, que les éléments de
style soient fortement mélangés au contenu.
XHTML doit respecter la forme suivante :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-s
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr" lang="fr">
<head>
<title>Exemple XHTML 1.0 strict</title>
</head>
<body>
<ul>
<li>Tous les éléments doivent être explicitement balisés.</li>
<li>Les balises fermantes ne sont pas optionnelles.</li>
<li>Les noms d’éléments et d’attributs <em class="important">doivent</em> être en minuscules.</
<li>Tous les attributs doivent avoir une valeur explicite <input type="checkbox" checked="check
<li>Les guillemets sont <em class="important">toujours</em> obligatoires autour des valeurs d’a
<li>Les balises auto-fermantes se terminent tous par un espace et un slash comme pour la balise
ou un retour à la ligne : <br /></li>
</ul>
</body>
</html>
8.2.6 Le prologue
Le prologue est la première ligne d’un document HTML ou XHTML et a la forme < ?xml
version="1.0" ?>. Il permet de savoir si l’on a affaire à un document XML et si c’est le cas, de connaître la
version applicable.
8.2.7 Le doctype
Le doctype est généralement défini tout de suite après le prologue et permet de savoir quelle DTD les éléments
non qualifiés doivent suivre.
Cas du HTML :
<!DOCTYPE html PUBLIC "-//IETF//DTD HTML 2.0//EN">
Cas du XTHML 1.0 strict :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
8.2. Savoir
87
Plone pour les intégrateurs, Version 1.0.0
Cas du XHTML 1.0 Transitional :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
Cas du XHTML 1.1 :
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
8.2.8 Les DTD et schémas
Que ce soit HTML ou XHTML, chacun des deux langages est défini par une DTD (Document Type Définition)
qui est une sorte de grammaire expliquant les combinaisons d’éléments et d’attributs possibles.
XML permet d’utiliser des schémas à la place des DTD, qui ont l’avantage d’être en XML et de mieux détailler
les éléments et attributs. Il y a ainsi moins d’interprétations possibles des spécifications.
8.2.9 Les documents bien formés
On dit d’un document XML qu’il est bien formé si chaque balise ouvrante a une balise fermante, si les attributs
ont bien tous des valeurs au moins vide.
8.2.10 Les documents validés
Un document XML est validé lorsqu’il respecte l’organisation des éléments prévue par une DTD ou un schéma.
La validation identifie la ou les DTD et Schémas à appliquer au document, va les chercher et vérifie que toutes les
règles de construction décrite dedans sont respectées.
8.2.11 Les commentaires
Les commentaires sont délimités par < !-- et -->.
8.2.12 Les espaces de noms
Pour permettre l’extension, XML a introduit la notion d’espace de nom, ainsi il est possible dans un élément de
définir un espace de nom liant un préfixe d’élément à un schéma ou une DTD et donc de mélanger des éléments
de natures différentes. Le format est xmlns :NomPrefixe="URL".
Exemple :
<ex:exemple
xmlns:formation="http://www.ecreall.com/formations/xml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:ex="http://example.org">
<formation:plone version="3 4">
<formation:python>
<p>Python c’est bien</p>
<a href="http://www.afpy.org">Association Francophone Python</p>
</formation:python>
</formation:plone>
</ex:exemple>
88
Chapitre 8. Rappel HTML et XML
Plone pour les intégrateurs, Version 1.0.0
8.3 Exercices
Écriture d’une page HTML et d’un document XML.
8.4 Ressources
–
–
–
–
–
–
–
Hypertexte
HTML
XHTML
XML
URL
W3C
Feuilles de styles
8.3. Exercices
89
Plone pour les intégrateurs, Version 1.0.0
90
Chapitre 8. Rappel HTML et XML
CHAPITRE 9
Concept de Python eggs
–
–
–
–
–
–
–
–
Définition
Savoir
Installation de Python et Distribute
Packaging Python
– Installation d’un egg
– Télécharger un package sans l’installer
– Création d’un environnement isolé avec virtualenv
– Suppression d’un egg
– Methode “originelle” pour installer un package
– Installation de virtualenvwrapper
Passons au développement
– Installation de la commande paster
– Création de votre premier egg
– Déclaration des dépendances
– Egg en mode développement
– Le hello world que tout le monde attend
– Les espaces de nom ou namespaces
L’API pkg_resources
Les entry points
– groupe console_scripts
Mise en place d’un Pypi privé avec PloneSoftwareCenter
– Installation de collective.dist pour Python 2.4 et 2.5
– Configuration des serveurs
– Enregistrement et upload
– Broken release
9.1 Définition
Les Python eggs sont des packages distribuables. La notion de egg doit être bien comprise pour comprendre la
suite. C’est la base des outils d’aujourd’hui comme zc.buildout qui sert au déploiement d’un site Plone et
paster pour la génération de squelette de projet.
9.2 Savoir
– distribute/setuptools
91
Plone pour les intégrateurs, Version 1.0.0
–
–
–
–
–
environnement isolé avec virtualenv
création d’un egg avec paster
metadata (description au format ReST, dépendances, extras)
installation via easy_install
entry points et plugins (paster utilise ce mécanisme de plugins)
9.3 Installation de Python et Distribute
Dans ce qui suit, je considère que vous êtes sous Ubuntu ou Debian et que vous souhaitez travailler sur Plone 4
qui requiert Python 2.6. Si vous voulez installer un Plone 3, il vous faudra Python 2.4, dans ce cas, remplacez 2.6
par 2.4 dans les instructions suivantes.
Installez les packages suivants :
$ sudo apt-get install build-essential python2.6 python2.6-dev
Le meta-paquet build-essential vous installera tout ce qu’il faut (compilateur gcc, make, etc.) pour compiler certains modules Python. Si par la suite vous avez une erreur disant que le fichier Python.h ne peut être trouvé,
c’est très probablement que vous n’avez pas le paquet python2.6-dev d’installé.
Sous Ubuntu, installez le gestionnaire de paquets distribute comme ceci :
$ wget http://python-distribute.org/distribute_setup.py
$ sudo python distribute_setup.py
Si vous voulez être sûr de la version de Python que vous utilisez, vous pouvez vérifier la version comme ceci :
$ python --version
Python 2.6.4
Et savoir exactement où il se trouve comme ceci :
$ which python
/usr/bin/python
Ce python est en fait un lien symbolique ici vers python2.6, comme on peut le voir :
$ ls -l /usr/bin/python
lrwxrwxrwx 1 root root 9 2009-11-07 17:08 /usr/bin/python -> python2.6
À tout moment, vous pouvez exécuter ces commandes pour savoir quel Python vous utilisez réellement.
Après l’installation de distribute, la commande easy_install est disponible pour installer de nouveaux eggs pour
Python 2.6.
9.4 Packaging Python
Un package Python peut être distribué sous la forme d’une simple archive (zip ou tar.gz).
Python inclu la librairie distutils afin de réaliser ces distributions source, mais celle-ci ne gère pas les dépendances entre packages. distribute est un fork de setuptools, une extension à distutils qui ajoute de
nombreuses fonctionnalités :
– dépendances (metadata install_requires)
– distribution binaire, egg
– entry points
Le package distribute fournit la commande easy_intall qui permet d’installer un package donné :
$ easy_install zope.interface
92
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
Il y a également pip qui lui propose un moyen alternatif à easy_install pour installer un package.
Tarek Ziadé et d’autres personnes travaillent sur l’amélioration de la gestion des packages Python avec le nouveau
package distutils2 qui remplacera distutils et distribute.
– implémentation d’une fonctionnalité de désinstallation d’un package
– ajout du metadata install_requires (entre autres) pour décrire les dépendances, mais la gestion des dépendances
se fera toujours avec une commande tierce.
Vous pouvez lire le billet de Tarek et les PEPs associés si vous êtes intéressé sur le sujet.
9.4.1 Installation d’un egg
La communauté Python possède un dépôt central où sont stockés tous les packages Python, c’est le Pypi (Python
Package Index), connu autrefois sous le nom de Cheese Shop. Son adresse : http ://pypi.python.org/pypi
Lorsque vous installez un package Python via easy_install, c’est sur cet index que le package est recherché.
En effet l’index par défaut est l’URL suivante : http ://pypi.python.org/simple
Exécutez easy_install Fabric, voici ce qui est exactement fait :
– connexion à l’index http ://pypi.python.org/simple
– recherche de Fabric dans la liste des liens, si un lien est trouvé, il est suivi
– nous arrivons donc sur http ://pypi.python.org/simple/Fabric/ Cette page contient une liste d’urls où l’on peut
télécharger directement l’egg, mais également toutes les urls contenues dans la description longue du egg.
– la liste fournie sur cette page est ensuite filtrée de la manière suivante :
– on donne priorité au egg binaire (bdist) qu’à la distribution source (sdist)
– on garde les packages liés à l’OS, donc si on est sous Windows, les eggs ayant win32 sont gardés
– seul les eggs utilisant la version de Python qu’on est en train d’utiliser sont gardés
– si aucun egg binaire n’est trouvé, alors on recherche une distribution source (tar.gz ou zip)
– il se peut qu’il n’y ait aucun lien direct vers un egg sur cette page, mais un lien vers une ou plusieurs urls où
l’on peut les télécharger (liens contenus dans long_description ou via l’option download_url précisé lors
de la création du egg). Dans ce cas-là, les liens sont suivis pour aller chercher une liste des versions.
Si le package n’a pas été trouvé sur l’index, alors on entame une nouvelle recherche, cette fois parmi tous les
find-links (éventuellement filtré par l’option -H/--allow-hosts) :
$ easy_install --find-links http://pkg.example.com/packages/ monpackage
Vous pouvez par exemple autoriser seulement les connexions vers votre intranet et pypi :
$ easy_install -H *.myintranet.example.com,*.python.org zope.interface
L’option -H/--allow-hosts permet aussi par exemple d’installer un package sans le réseau, en interdissant
toutes les URLs et en spécifiant un dossier somedir où aller chercher le package SomePackage :
$ easy_install -H None -f somedir SomePackage
Au lieu de préciser l’option en ligne de commande, vous pouvez le mettre dans le fichier de configuration
~/.pydistutils.cfg :
[easy_install]
allow_hosts = *.myintranet.example.com
Dans ce cas, seul les packages téléchargeables sur myintranet.example.com pourront être installés.
Il est possible de changer l’index par défaut par lequel les eggs sont recherché via l’option -i/--index-url.
Pypi possède des miroirs
Voir aussi le projet pour créer et/ou utiliser des miroirs de pypi.
Si l’on veut utiliser un miroir ou un index privé par exemple. Nous traiterons le cas d’un index privé avec le produit
PloneSoftwareCenter par la suite.
9.4. Packaging Python
93
Plone pour les intégrateurs, Version 1.0.0
9.4.2 Télécharger un package sans l’installer
Il est possible de télécharger le code source (sdist) d’un package sans pour autant l’installer :
$ easy_install -b . -e zope.interface
Exécutez easy_install -h pour connaitre la signification des options.
En savoir plus : Documentation EasyInstall
9.4.3 Création d’un environnement isolé avec virtualenv
Il est fréquent de vouloir tester plusieurs versions d’un framework. Admettons que vous ayez zope 3.4 installé
globalement, comment pouvez-vous tester zope 3.5 sans que votre installation de zope 3.4 interfère ? La solution
est de créer une environnement isolé avec virtualenv.
Lisez le tutoriel virtualenv sur grok.zope.org pour savoir comment l’installer et l’utiliser. Revenez ici lorsque c’est
fait.
Si ce n’est déjà fait, installez virtualenv avec Python 2.4 :
$ easy_install-2.4 virtualenv
Bien, vous êtes revenu. Maintenant expliquons comment la magie opère.
Dans Python, vous avez dans sys.path la liste des chemins dans lesquels on peut trouver des packages Python :
$ which python2.4
/usr/bin/python2.4
$ python2.4
>>> import sys
>>> sys.path
[’’, ’/usr/lib/python2.4’, ’/usr/lib/python2.4/plat-linux2’,
’/usr/lib/python2.4/lib-tk’, ’/usr/lib/python2.4/lib-dynload’,
’/usr/local/lib/python2.4/site-packages’,
’/usr/lib/python2.4/site-packages’,
’/usr/lib/python2.4/site-packages/Numeric’,
’/usr/lib/python2.4/site-packages/PIL’,
’/usr/lib/python2.4/site-packages/gst-0.10’,
’/var/lib/python-support/python2.4’,
’/usr/lib/python2.4/site-packages/gtk-2.0’,
’/var/lib/python-support/python2.4/gtk-2.0’]
Créons un environnement nommé myenv :
$ virtualenv myenv --distribute
Ce que fait cette commande peut se résumer plus ou moins à ces commandes :
$ mkdir -p myenv/bin myenv/lib/python2.4/site-packages
$ cp /usr/bin/python2.4 myenv/bin/python
$ cp /usr/bin/python2.4 myenv/bin/python2.4
création de liens symboliques vers les modules de la librairies standard installation de distribute (ou
setuptools à défaut du paramètre --distribute) dans cet environnement, ce qui génère les commandes command :bin/easy_install et bin/easy_install-2.4 (c’est le même exécutable) et la création d’un script
bin/activate.
Notez que python (sans suffixe) est la version 2.5 sous Ubuntu 8.04 et 8.10 :
94
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
$ which python
/usr/bin/python
$ python -V
Python 2.5.2
Entrons dans le dossier et activons l’environnement :
$ cd myenv/
$ source bin/activate
Le prompt indique que votre environnement est actif. Jetez un œil au source du fichier bin/activate, il n’y
a rien de magique là dedans, il change seulement la variable d’environnement PATH pour y inclure au début le
dossier myenv/bin. La partie essentielle de ce script est :
$ export PATH="/home/vincentfretin/myenv/bin:$PATH"
Cela a son importance, précédement python était le binaire /usr/bin/python qui est la version 2.5 de
Python sous Ubuntu 8.04 et 8.10. Maintenant c’est le python de l’environnement, qui est un Python 2.4 :
(myenv)$ which python
.../myenv/bin/python
(myenv)$ python -V
Python 2.4.5
Maintenant regardons le sys.path :
(myenv)$ python
>>> import sys
>>> sys.path
[’’,
’/home/vincentfretin/myenv/lib/python2.4/site-packages/setuptools-0.6c11-py2.4.egg’,
’/home/vincentfretin/myenv/lib/python2.4’,
’/home/vincentfretin/myenv/lib/python2.4/plat-linux2’,
’/home/vincentfretin/myenv/lib/python2.4/lib-tk’,
’/home/vincentfretin/myenv/lib/python2.4/lib-dynload’, ’/usr/lib/python2.4’,
’/usr/lib64/python2.4’, ’/usr/lib/python2.4/plat-linux2’,
’/usr/lib/python2.4/lib-tk’, ’/usr/lib64/python2.4/lib-tk’,
’/home/vincentfretin/myenv/lib/python2.4/site-packages’,
’/usr/local/lib/python2.4/site-packages’, ’/usr/lib/python2.4/site-packages’,
’/usr/lib/python2.4/site-packages/Numeric’,
’/usr/lib/python2.4/site-packages/PIL’,
’/usr/lib/python2.4/site-packages/gst-0.10’,
’/var/lib/python-support/python2.4’,
’/usr/lib/python2.4/site-packages/gtk-2.0’,
’/var/lib/python-support/python2.4/gtk-2.0’]
Vous voyez que les chemins vers les dossiers globaux sont toujours inclus mais que les premiers sont ceux de
notre environnement. En effet vous pouvez utiliser la bibliothèque PIL qui est installé globalement :
>>> import PIL
Sous Ubuntu 9.04, PIL n’est pas disponible sous Python 2.4. Ici import PIL est seulement utilisé comme
exemple d’import d’un package installé globalement. Le package virtualenv a aussi été installé globalement,
donc vous pouvez utilisez import virtualenv à la place pour tester.
En général vous voulez un environnement isolé des packages extérieurs, c’est le rôle de l’option
--no-site-packages de virtualenv. Nous allons recréer l’environnement avec cette option, tout d’abord
désactivez l’environnement :
(myenv)$ deactivate
9.4. Packaging Python
95
Plone pour les intégrateurs, Version 1.0.0
deactivate est juste une fonction bash créée lorsque vous avez sourcé bin/activate.
Supprimez votre environnement et recréez le avec l’option --no-site-packages :
$ cd ..
$ rm -rf myenv
$ virtualenv --no-site-packages myenv
Maintenant voyez par vous même la différence :
$ cd myenv/
$ . bin/activate
(myenv)$ python
>>> import sys
>>> sys.path
[’’,
’/home/vincentfretin/myenv/lib/python2.4/site-packages/setuptools-0.6c9-py2.4.egg’,
’/home/vincentfretin/myenv/lib/python2.4’,
’/home/vincentfretin/myenv/lib/python2.4/plat-linux2’,
’/home/vincentfretin/myenv/lib/python2.4/lib-tk’,
’/home/vincentfretin/myenv/lib/python2.4/lib-dynload’, ’/usr/lib/python2.4’,
’/usr/lib64/python2.4’, ’/usr/lib/python2.4/plat-linux2’,
’/usr/lib/python2.4/lib-tk’, ’/usr/lib64/python2.4/lib-tk’,
’/home/vincentfretin/myenv/lib/python2.4/site-packages’]
Le dossier PIL n’est plus là, comme l’atteste l’exception ImportError :
>>> import PIL
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ImportError: No module named PIL
Vous pouvez installer PIL dans cet environnement comme ceci :
easy_install --find-links http://dist.plone.org/thirdparty/ PIL
(L’archive PIL de pypi n’est pas easy installable.)
Ici, nous avons installé virtualenv avec easy_install-2.4, comment créer un environnement avec une autre version
de Python ? virtualenv possède une option -p pour préciser un exécutable python alternatif :
$ virtualenv -p /usr/bin/python --no-site-packages --distribute myenv25
$ cd myenv25
$ . bin/activate
Nous allons utiliser ce nouvel environnement pour installer Fabric qui nécessite Python >= 2.5. Vérifiez que
vous avez la package Ubuntu python2.5-dev ou python2.6-dev d’installé, il est nécessaire pour compiler pycrypto, une dépendance de Fabric. Fabric est un outil pour scripter les deploiements. Nous n’allons pas utiliser
easy_install Fabric ici, mais récupérer l’archive pour l’installer.
Nous téléchargons l’archive avec wget et exécutons ensuite easy_install avec l’archive en paramètre pour installer
le package :
(myenv25)$ wget http://git.fabfile.org/cgit.cgi/fabric/snapshot/fabric-0.9a3.tar.gz
(myenv25)$ easy_install fabric-0.9a3.tar.gz
Nous aurions très bien pu faire directement easy_install http ://git.fabfile.org/cgit.cgi/fabric/snapsho
Vous pouvez remarquer que Fabric et ses dépendances ont été installées en eggs zippés :
96
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
(myenv25)$
total 1064
-rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--
ls -l lib/python2.5/site-packages/
1
1
1
1
1
1
vincentfretin
vincentfretin
vincentfretin
vincentfretin
vincentfretin
vincentfretin
vincentfretin
306 2009-05-25 11:35 easy-install.pth
vincentfretin 71581 2009-05-25 11:35 Fabric-0.9a3-py2.5.egg
vincentfretin 296831 2009-05-25 11:35 paramiko-1.7.4-py2.5.egg
vincentfretin 358122 2009-05-25 11:35 pycrypto-2.0.1-py2.5-linux-x86_64
vincentfretin 328025 2009-05-25 11:34 distribute-0.6.8-py2.5.egg
vincentfretin
29 2009-05-25 11:34 setuptools.pth
Tous les eggs ne sont pas installés zippés. C’est le mainteneur du package qui décide si son egg est “zip safe” ou
non. Un package n’est par exemple pas zip safe s’il utilise la variable spéciale __file__ dans son code.
Vous vous demandez à quoi sert ces fichiers setuptools.pth et easy-install.pth n’est-ce pas ? Un
petit rappel Python va vous faire du bien alors.
Que contient ces fichiers xyz.pth (pour path) ? Comme son extension le suggère, ces fichiers contiennent une
liste de chemins où l’on peut trouver des packages :
(myenv25)$ cat lib/python2.5/site-packages/setuptools.pth
./distribute-0.6.8-py2.5.egg
(myenv25)$ cat lib/python2.5/site-packages/easy-install.pth
import sys; sys.__plen = len(sys.path)
./distribute-0.6.8-py2.5.egg
./Fabric-0.9a3-py2.5.egg
./paramiko-1.7.4-py2.5.egg
./pycrypto-2.0.1-py2.5-linux-x86_64.egg
import sys; new=sys.path[sys.__plen:]; del sys.path[sys.__plen:]; p=getattr(sys,’__egginsert’,0);
Comme vous le voyez, la commande easy_install maintient dans le fichier easy-install.pth une liste des
eggs qu’elle a installés.
Au démarrage de Python, tous les packages python (dans le sens d’un dossier contenant un fichier
__init__.py) se trouvant dans lib/python2.5/site-packages/ sont ajoutés au sys.path. Ça c’est
la première étape, et dans notre cas, il n’y a aucun packages. La deuxième étape recherche des fichiers xyz.pth,
les lit et inclu les chemins inclus si un package s’y trouve.
La première et dernière ligne du fichier easy-install.pth sont utilisés pour ajouter les eggs au début de
sys.path pour prendre précédence aux packages éventuellement installés.
9.4.4 Suppression d’un egg
Il n’y a pas de commande uninstall pour désinstaller un egg. Une implémentation est en cours dans distutils2.
Pour le moment, il faut donc désinstaller manuellement et là il faut savoir ce que l’on fait.
La première chose qui vient à l’esprit est de supprimer le egg du site-packages. C’est très bien mais cela ne suffit
pas comme nous allons le voir.
Nous allons désinstaller Fabric pour l’installer d’une autre manière. Nous allons profiter de cette désintallation
pour revenir sur le fichier xyz.pth.
Notez bien que nous avons dans le sys.path setuptools, Fabric et paramiko, dans le même ordre que listé
dans easy-install.pth :
(myenv25)vincentfretin@lelouch:~/myenv25$ python
Python 2.5.2 (r252:60911, Oct 5 2008, 19:29:17)
[GCC 4.3.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.path
[’’,
’/home/vincentfretin/myenv25/lib/python2.5/site-packages/setuptools-0.6c11-py2.5.egg’,
9.4. Packaging Python
97
Plone pour les intégrateurs, Version 1.0.0
’/home/vincentfretin/myenv25/lib/python2.5/site-packages/Fabric-0.9a3-py2.5.egg’,
’/home/vincentfretin/myenv25/lib/python2.5/site-packages/paramiko-1.7.4-py2.5.egg’,
’/home/vincentfretin/myenv25/lib/python2.5/site-packages/pycrypto-2.0.1-py2.5-linux-x86_64.egg’,
’/home/vincentfretin/myenv25/lib/python2.5’, ...]
Maintenant supprimons le egg de Fabric :
(myenv25)vincentfretin@lelouch:~/myenv25$ rm lib/python2.5/site-packages/Fabric-0.9a3-py2.5.egg
Mais nous n’avons pas supprimé l’entrée dans easy-install.pth. Allons nous encore avoir
/home/vincentfretin/myenv25/lib/python2.5/site-packages/Fabric-0.9a3-py2.5.egg
dans le sys.path ? Voyons voir :
(myenv25)vincentfretin@lelouch:~/myenv25$ python
Python 2.5.2 (r252:60911, Oct 5 2008, 19:29:17)
[GCC 4.3.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.path
[’’,
’/home/vincentfretin/myenv25/lib/python2.5/site-packages/setuptools-0.6c9-py2.5.egg’,
’/home/vincentfretin/myenv25/lib/python2.5/site-packages/paramiko-1.7.4-py2.5.egg’,
’/home/vincentfretin/myenv25/lib/python2.5/site-packages/pycrypto-2.0.1-py2.5-linux-x86_64.egg’,
’/home/vincentfretin/myenv25/lib/python2.5’, ...]
Et bien non, Python n’a trouvé aucun package Python ./Fabric-0.9a3-py2.5.egg qui n’existe plus, il ne
l’a donc pas ajouté dans le sys.path.
Pour faire une désintallation propre d’un egg, il faut :
– supprimer le egg
– supprimer l’entrée dans easy-install.pth
– supprimer les éventuels scripts qui ont été généré à l’installation, ici bin/fab.
9.4.5 Methode “originelle” pour installer un package
easy_install fait partie du package distribute / setuptools. Si distribute ou setuptools n’est
pas disponible dans votre environnement, on peut très bien installer un package en l’extrayant et exécutant la
commande python setup.py install :
(myenv25)$ tar xvf fabric-0.9a3.tar.gz
(myenv25)$ cd fabric-0.9a3/
(myenv25)$ python setup.py install
En fait, c’est exactement ce que fait la commande easy_install.
9.4.6 Installation de virtualenvwrapper
virtualenvwrapper est un ensemble de fonctions bash pour gérer vos environnements.
Pour l’installer :
$ sudo easy_install virtualenvwrapper
Éditez ensuite votre ~/.bashrc pour sourcer le fichier /usr/local/bin/virtualenvwrapper.sh.
Sur Ubuntu, j’ai l’habitude de décommenter dans ~/.bashrc les 3 lignes concernant l’inclusion de
~/.bash_aliases. Je met ensuite dans ce fichier tous les alias et autres variables d’environnement que je
veux. Ici nous voulons ces deux lignes :
98
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
TMPDIR=/tmp
source /usr/local/bin/virtualenvwrapper.sh
virtualenvwrapper utilise le dossier ~/.virtualenvs par défaut pour créer et chercher les environnements :
$ mkdir ~/.virtualenvs
Démarrez un nouveau terminal, vous avez maintenant à disposition les commandes suivantes :
– workon : affiche la liste des environnements contenu dans ~/.virtualenvs
– workon myenv : active l’environnement myenv
– mkvirtualenv myenv : crée l’environnement myenv avec la commande virtualenv et l’active Tous les paramètres données à mkvirtualenv serons donnés à la commande command :virtualenv.
– rmvirtualenv myenv : supprime l’environnement myenv
– cdvirtualenv : va dans le dossier de l’environnement actif
– cdsitepackages : va dans le dossier site-packages de l’environnement actif
– lssitepackages : liste les eggs installés de l’environnement actif
– cpvirtualenv : copie un environnement existant
Donc avant pour activer un environnement, vous faisiez :
$ cd myenv
$ . bin/activate
Maintenant vous n’avez qu’à taper workon myenv où que vous soyez.
9.5 Passons au développement
9.5.1 Installation de la commande paster
Dans ce qui suit je travaille dans mon environnement myenv, je n’indiquerai plus le “(myenv)” dans le prompt.
Installez le egg PasteScript.
Le egg PasteScript fournit la commande paster avec laquelle on peut créer des squelettes de code.
Pour lister les templates disponibles :
$ paster create --list-templates
Available templates:
basic_package: A basic setuptools-enabled package
paste_deploy:
A web application deployed through paste.deploy
Il n’y a pas beaucoup de templates par défaut.
Installez le egg ZopeSkel qui fournit divers templates et reexécutez la commande :
$ paster create --list-templates
Available templates:
archetype:
A Plone project that uses Archetypes
basic_namespace:
A project with a namespace package
basic_package:
A basic setuptools-enabled package
basic_zope:
A Zope project
kss_plugin:
A KSS plugin template
nested_namespace:
A project with two nested namespaces.
paste_deploy:
A web application deployed through paste.deploy
plone:
A Plone project
plone2.5_buildout: A buildout for Plone 2.5 projects
plone2.5_theme:
A Theme for Plone 2.5
plone2_theme:
A Theme Product for Plone 2.1 & Plone 2.5
plone3_buildout:
A buildout for Plone 3 projects
plone3_portlet:
A Plone 3 portlet
9.5. Passons au développement
99
Plone pour les intégrateurs, Version 1.0.0
plone3_theme:
plone_app:
plone_hosting:
plone_pas:
recipe:
silva_buildout:
zope2_buildout:
A Theme for Plone 3.0
A Plone App project
Plone hosting: buildout with ZEO and any Plone version
A Plone PAS project
A recipe project for zc.buildout
A buildout for Silva projects
A buildout to create a blank Zope 2 instance
Ah il y a déjà plus de choix !
Ceux que nous utiliserons par la suite sont basic_namespace, plone3_buildout, plone3_theme.
En fait, vous auriez très bien pu installer uniquement ZopeSkel car PasteScript en est une dépendance.
9.5.2 Création de votre premier egg
Pour créer un squelette, vous choisissez votre template et exécutez :
$ paster create -t nom_de_la_template
Créez votre premier egg :
$ paster create -t basic_namespace
Selected and implied templates:
ZopeSkel#basic_namespace A project with a namespace package
Enter project name: foo.bar
Variables:
egg:
foo.bar
package: foobar
project: foo.bar
Enter namespace_package (Namespace package (like plone)) [’plone’]: foo
Enter package (The package contained namespace package (like example)) [’example’]: bar
Enter version (Version) [’1.0’]:
Enter description (One-line description of the package) [’’]: My first package
Enter long_description (Multi-line description (in reST)) [’’]:
Enter author (Author name) [’’]: Vincent Fretin
Enter author_email (Author email) [’’]: [email protected]
Enter keywords (Space-separated keywords/tags) [’’]:
Enter url (URL of homepage) [’’]:
Enter license_name (License name) [’GPL’]:
Enter zip_safe (True/False: if the package can be distributed as a .zip file) [False]:
Creating template basic_namespace
Creating directory ./foo.bar
Recursing into +namespace_package+
Creating ./foo.bar/foo/
Recursing into +package+
Creating ./foo.bar/foo/bar/
Copying __init__.py_tmpl to ./foo.bar/foo/bar/__init__.py
Copying __init__.py_tmpl to ./foo.bar/foo/__init__.py
Copying README.txt_tmpl to ./foo.bar/README.txt
Recursing into docs
Creating ./foo.bar/docs/
Copying HISTORY.txt_tmpl to ./foo.bar/docs/HISTORY.txt
Copying setup.cfg to ./foo.bar/setup.cfg
Copying setup.py_tmpl to ./foo.bar/setup.py
Running /home/vincentfretin/myenv/bin/python2.4 setup.py egg_info
Voyons ce qu’il a généré :
100
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
$ tree foo.bar
foo.bar/ (un egg nommé foo.bar)
|-- README.txt
|-- docs
|
‘-- HISTORY.txt
|-- foo (un package foo)
|
|-- __init__.py
|
‘-- bar (un package bar imbriqué)
|
‘-- __init__.py
|-- foo.bar.egg-info (les fichiers de ce dossier sont générés)
|
|-- PKG-INFO
|
|-- SOURCES.txt
|
|-- dependency_links.txt
|
|-- entry_points.txt
|
|-- namespace_packages.txt
|
|-- not-zip-safe
|
|-- requires.txt
|
‘-- top_level.txt
|-- setup.cfg
‘-- setup.py (le fichier le plus important)
Le dossier foo.bar.egg-info est généré automatiquement avec la commande python2.4 setup.py egg_info
(dernière commande exécutée par paster).
Ce dossier ne sera donc pas ajouté au gestionnaire de version comme nous le verrons plus loin.
Le fichier setup.py contient les données que vous avez entrées.
9.5.3 Déclaration des dépendances
L’option install_requires dans setup.py permet d’indiquer des dépendances, ici notre egg dépend de
setuptools.
Les dépendances sont vérifiées à l’installation de l’egg. install_requires est une liste de Requirement.
requirement
::=
nom_egg
[(“>=” | “>” | “<” | “<=” | “==” | ” !=”) version]
En savoir plus : Declaring Dependencies (concepts d’extras)
L’option entry_points sera expliquée plus loin.
9.5.4 Egg en mode développement
Installons tout de suite ce nouvel egg pour pouvoir l’importer.
La première chose a laquelle vous pensez est de faire python setup.py install et vous avez raison !
Mais l’inconvénient dans ce cas-là est qu’à chaque fois que vous allez changer quelque chose à votre package,
vous devrez reexécuter cette commande.
Nous avons une commande develop, qui est bien mieux pour installer un egg tout en le développant. Faites donc
ceci :
$ cd foo.bar
$ python setup.py develop
Cette commande, au lieu de copier le dossier dans site-packages, crée un fichier foo.bar.egg-link
qui n’est autre finalement qu’un lien symbolique multi-plateforme qui pointe vers le dossier de votre egg en
développement.
En savoir plus : “Development Mode”
9.5. Passons au développement
101
Plone pour les intégrateurs, Version 1.0.0
9.5.5 Le hello world que tout le monde attend
Allez-y maintenant, ouvrez un python et importez votre package :
$ python
>>> import foo.bar
Et le “hello world” me direz vous ? Bien je vois que vous avez l’habitude.
Éditez le fichier foo/__init__.py pour y ajouter :
print "Hello"
Réimportez votre module :
$ python
>>> import foo.bar
Hello
Éditez le fichier foo/bar/__init__.py et ajoutez-y :
print "world!"
Réimportez le module :
$ python
>>> import foo.bar
Hello
world!
Et voilà !
En plus l’exemple sert pour faire un petit rappel Python : Face à import foo.bar que fait l’interpréteur
Python ?
Eh bien il regarde dans le sys.path un package foo (dossier foo avec un fichier __init__.py dedans) ou
un module foo (fichier foo.py), dans cet ordre.
Ici un package foo est trouvé, et le contenu du fichier __init__.py est exécuté.
On passe ensuite à bar, un package ou un module est recherché à l’intérieur du package : mod :foo.
Ici un package bar est trouvé, le contenu de son fichier __init__.py est exécuté.
9.5.6 Les espaces de nom ou namespaces
À quoi sert le code dans foo/__init__.py ? Très bonne question !
Créez un egg comme précédemment nommé : file :foo.rab (pas très inspiré), et installez le en mode développé.
Vous l’avez fait sans regarder le texte au dessus, c’est très bien !
Vous avez usé de la flêche haute, avouez le. C’est encore mieux !
Éditez foo.rab/foo/__init__.py :
print "Bonjour"
Éditez foo.rab/foo/rab/__init__.py :
print "le monde"
102
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
On y est. Vérifions que foo.bar et foo.rab sont dans notre sys.path et sont bien dans cette ordre :
$ python
>>> import sys
>>> sys.path
[..., ’/home/vincentfretin/src/foo.bar’, ’/home/vincentfretin/src/foo.rab’,
...]
Comme dit plus haut, Python recherche un package nommé foo, il en trouve un, exécute le contenu de
__init__.py et normalement devrait s’arrêter là.
Donc cela devrait donner ceci :
>>> import foo
Hello
car foo.bar étant en premier dans le sys.path.
Au lieu de ça, qu’avons-nous ?
>>> import foo
Hello Bonjour
Il se peut que vous ayez “Bonjour Hello” comme ordre, c’est assez mystérieux. L’essentiel est que vous ayez les
deux.
Ensuite :
>>> import foo.rab
le monde
>>> import foo.bar
world!
Le code de foo.bar/foo/__init__.py indique que : mod :foo est un espace de nom. Et cela change le
comportement de l’import.
Au lieu de s’arrêter au premier package foo trouvé, la recherche continue et tous les packages foo trouvés sont
exécutés.
Si foo n’était pas déclaré comme espace de nom dans l’egg foo.bar, alors vous auriez eu ceci :
>>> import foo.rab
Traceback (most recent call last)
File "<stdin>", line 1, in ?
ImportError: No module named rab
Vous pouvez faire le test en commentant namespace_packages=[’foo’] du setup.py de foo.bar.
Il faut réexécuter python setup.py egg_info (la commande egg_info est également exécutée lors d’un
install ou d’un develop)
pour mettre à jour les metadonnées du egg situées dans le dossier foo.bar.egg-info. Commentez également
les lignes dans foo.bar/foo/__init__.py.
En temps normal, ne mettez pas de code dans les fichiers __init__.py des packages servant d’espace de nom
comme le dit la documentation de setuptools.
En savoir plus : Namespace Packages
9.5. Passons au développement
103
Plone pour les intégrateurs, Version 1.0.0
9.6 L’API pkg_resources
setuptools fournit un module pkg_resources avec lequel on peut par exemple récupérer la version d’un egg.
Cet API sert à lire les différents fichiers du dossier .egg-info.
Exemple pour récupérer la version du egg foo.bar installé :
$ python
>>> import pkg_resources
>>> d = pkg_resources.get_distribution("foo.bar")
>>> d.version
’1.0dev’
>>> d.location
’/home/vincentfretin/src/foo.bar’
En savoir plus : Documentation PkgResources
9.7 Les entry points
Revenons sur l’option entry_points dans setup.py.
Cette option sert à définir des points d’entrées pour le egg. On peut utiliser cette notion pour réaliser des plugins.
Reprenons les eggs PasteScript et ZopeSkel. Comment PasteScript a fait pour découvrir les nouveaux
templates installés par : mod :ZopeSkel ?
ZopeSkel a défini des entry points pour le groupe paste.paster_create_template :
$ cdsitepackages
$ cat ZopeSkel-2.11.1-py2.4.egg/EGG-INFO/entry_points.txt
[paste.paster_create_template]
basic_namespace = zopeskel:BasicNamespace
plone3_theme = zopeskel:Plone3Theme
plone3_buildout = zopeskel:Plone3Buildout
où basic_namespace est un nom, zopeskel est un module à la racine du egg ZopeSkel et
BasicNamespace un callable, ici une classe.
et PasteScript lui fait une recherche des eggs déclarant
paste.paster_create_template avec l’API pkg_resources :
des
entry
points
pour
$ python
>>> import pkg_resources
>>> list(pkg_resources.iter_entry_points(’paste.paster_create_template’))
[EntryPoint.parse(’basic_namespace = zopeskel:BasicNamespace’),
EntryPoint.parse(’plone3_theme = zopeskel:Plone3Theme’),
EntryPoint.parse(’plone3_buildout = zopeskel:Plone3Buildout’), ...]
On peut charger le callable d’un entry point, souvent une classe :
>>> entry_points = list(pkg_resources.iter_entry_points(’paste.paster_create_template’))
>>> ep = entry_points[0]
>>> ep
EntryPoint.parse(’basic_package = paste.script.templates:BasicPackage’)
>>> BasicPackage = ep.load()
>>> BasicPackage
<class ’paste.script.templates.BasicPackage’>
En savoir plus : Dynamic Discovery of Services and Plugins
104
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
9.7.1 groupe console_scripts
Le groupe console_scripts est spécial. Il est utilisé lors de l’installation du egg pour générer les scripts dans
le dossier bin.
Pour générer un script bin/fab, le egg Fabric définit dans son setup.py :
entry_points={
’console_scripts’: [
’fab = fabric.main:main’,
]
},
On peut également l’écrire de la manière suivante directement :
entry_points="""
[console_scripts]
fab = fabric.main:main
""",
Dans les deux cas, le fichier entry_points.txt généré sera normalisé comme ceci :
[console_scripts]
fab = fabric.main:main
Concrétement, exécuter la commande fab revient à faire :
$ python
>>> from fabric.main import main
>>> main()
En savoir plus : Automatic Script Creation
9.8 Mise en place d’un Pypi privé avec PloneSoftwareCenter
Créez une instance Plone avec l’id “site” sur une machine servant de serveur (Installation via l’Unified Installer),
nous allons l’appeler devagile, avec la résolution DNS dans /etc/hosts :
10.56.8.47
devagile
Il est très facile de transformer une instance Plone en un Pypi pour votre entreprise en installant le produit Products.PloneSoftwareCenter.
Créez un site Plone avec comme id site, installez le module et créez une instance de PloneSoftwareCenter nommé
products à la racine de Plone.
L’URL de ce Pypi sera donc http ://devagile :8080/site/products
9.8.1 Installation de collective.dist pour Python 2.4 et 2.5
Si vous utilisez Python 2.4 ou 2.5, il vous faut installer collective.dist qui introduit deux nouvelles commandes
mregister et mupload pour pouvoir enregister votre egg sur plusieurs serveurs.
Si vous utilisez Python 2.6, remplacez mregister par register, et mupload par upload dans ce qui suit.
En effet le support de serveurs multiples n’a été introduit qu’à partir de la version 2.6 de Python.
9.8. Mise en place d’un Pypi privé avec PloneSoftwareCenter
105
Plone pour les intégrateurs, Version 1.0.0
9.8.2 Configuration des serveurs
Il faut tout d’abord configurer votre fichier ~/.pypirc :
[distutils]
index-servers =
pypi
mycompany
[pypi]
username:user
password:password
[mycompany]
repository:http://devagile:8080/site/products
username:ploneuser
password:password
Sous Windows vous ne pouvez pas créer ce fichier .pypirc avec le gestionnaire de fichiers, mais dans un shell,
vous pouvez.
Dans un shell dos, allez dans C :\Profiles\User, et créez le fichier avec la commande :
edit .pypirc
9.8.3 Enregistrement et upload
Exécutez ensuite :
Avec Python < 2.6
$ python setup.py mregister -r mycompany sdist --formats=zip mupload -r mycompany
Avec Python >= 2.6 :
$ python setup.py register -r mycompany sdist --formats=zip upload -r mycompany
–
–
–
–
mregister permet d’enregistrer le egg sur le serveur
sdist permet de créer une distribution source
mupload transfère sur la distribution source vers le serveur
-r mycompany précise d’enregistrer et de transfèrer sur le serveur mycompany (r pour repository dans
doute). Si cette option n’est pas précisée, c’est le serveur Pypi d’origine.
– --formats=zip, génère une archive au format zip. Par défaut sous Linux, une archive tar.gz est générée, le
module tarfile dans Python < 2.6 semble avoir certains problèmes de lecture de ces archives.
La commande mregister exécute implicitement la commande egg_info. Cette commande génère entre autres le
numéro de version.
Le fichier setup.cfg est lu par cette commande, il configure quelques options liées à la génération du numéro
de version :
$ cat setup.cfg
[egg_info]
tag_build = dev
tag_svn_revision = true
La version générée sera donc de la forme “1.0dev-r1”.
Pour une release stable, on supprime généralement ce fichier pour que la version soit simplement “1.0”.
On peut également laisser le fichier en place et écraser la configuration en ligne de commande comme ceci :
106
Chapitre 9. Concept de Python eggs
Plone pour les intégrateurs, Version 1.0.0
$ python setup.py egg_info -RDb "" mregister -r mycompany sdist --formats=zip mupload -r mycompany
L’option --formats=zip permet de générer une archive zip au lieu d’une archive tar.gz par défaut sous Linux.
Avec python setup.py sdist --help-formats, vous pouvez voir la liste des formats possibles d’archives.
Si vous voulez par exemple créer une archive zip et tar.gz, vous pouvez spécifier l’option
--formats=zip,gztar.
Regardez la signification des options avec :
$ python setup.py egg_info -h
--tag-build (-b)
Specify explicit tag to add to version number
--no-svn-revision (-R)
Don’t add subversion revision ID [default]
--no-date (-D)
Don’t include date stamp [default]
Nous verrons par la suite comment faire une release en bonne et due forme avec le gestionnaire de version subversion.
On peut remplacer sdist par bdist_egg pour générer un egg, une distribution binaire.
La convention est de générer un bdist_egg pour chaque version de Python pour la plateforme Windows si le
egg contient des librairies C à compiler.
Pour les autres OS, la distribution source sera récupéré et les librairies C seront compilées à l’installation.
9.8.4 Broken release
Créez un nouvel environnement testenv :
$ mkvirtualenv testenv
Essayez maintenant d’installer foo.bar 1.0 à partir de votre pypi :
$ easy_install -i http://devagile:8080/site/products/simple foo.bar
Il y a une erreur à l’installation disant qu’il ne trouve pas le fichier docs/HISTORY.txt.
La release est cassée car elle ne contient pas le dossier docs. Et nous avons besoin du fichier
docs/HISTORY.txt pour la long_description.
Le dossier docs est manquant car dans setup.py nous avons package=find_packages, ça recherche seulement les dossiers contenant un fichier __init__.py. docs n’étant pas un package, il n’a pas été inclu dans
l’archive.
Pour régler le problème, il faut mettre le code source dans un dépôt subversion et grâce à l’option
include_package_data=True dans setup.py, tous les fichiers subversionnés seront ajoutés à l’archive.
Note : Vous pouvez créer facilement un dépôt subversion comme ceci :
svnadmin create Formation
Et pour faire un checkout :
svn co file:///home/vincentfretin/Formation
Donc on va importer notre code dans le dépôt Formation :
$ svn import foo.bar/ http://devagile/Formation/foo.bar -m "First import of foo.bar"
Attention, le dossier .egg-info a été commité ! Nous allons le supprimer de subversion :
9.8. Mise en place d’un Pypi privé avec PloneSoftwareCenter
107
Plone pour les intégrateurs, Version 1.0.0
$
$
$
$
svn co http://devagile/Formation
cd Formation/foo.bar
svn rm foo.bar.egg-info dist
svn ci -m "Delete egg-info and dist directories"
Nous allons donc maintenant faire une nouvelle release de foo.bar, pour cela incrémentez la version dans
setup.py, mettez 1.1, éditez le fichier docs/HISTORY.txt pour ajouter une information au changelog,
commitez et refaites la release.
Nous allons faire pareil pour foo.rab, mais nous allons tout d’abord configurer l’option global-ignores
dans ~/.subversion/config pour ignorer le dossier .egg-info lors de l’import.
Ouvrez le fichier ~/.subversion/config et configurez global-ignores comme suit :
global-ignores = *.o *.lo *.la #*# .*.rej *.rej .*~ *~ .#* .DS_Store *.pyc *.pyo .installed.cfg bi
Vous pouvez maintenant importer le code source dans subversion et faire la release.
108
Chapitre 9. Concept de Python eggs
CHAPITRE 10
Introduction à zc.buildout
Author Vincent Fretin
Contributors
Révision https ://svn.plone.org/svn/collective/collective.trainingmanual/trunk/fr/integrateur/source/presentation_buildout.txt
Copyright (C) 2010 Vincent Fretin <vincentfretin AT gmail.com>.
Chacun est autorisé à copier, distribuer et/ou modifier ce document suivant les termes de la licence
Paternité-Pas d’Utilisation Commerciale-Partage des Conditions Initiales à l’Identique 2.0 France accessible à
http ://creativecommons.org/licenses/by-nc-sa/2.0/fr
Le code source présent dans ce document est soumis aux conditions de la « Zope Public License », Version 2.1
(ZPL).
THE SOURCE CODE IN THIS DOCUMENT AND THE DOCUMENT ITSELF IS PROVIDED “AS IS” AND
ANY AND ALL EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT,
AND FITNESS FOR A PARTICULAR PURPOSE.
–
–
–
–
–
–
–
–
–
–
–
–
–
–
Définition
Introduction
Organisation d’un buildout
Section principale [buildout]
Partage du dossier eggs et downloads
Pinning des versions
Extension buildout.dumppickedversions
Option extends
– Option extends-cache
Recipe collective.recipe.omelette
Utilisation de variable
Repinning et fusion de section de données
Ordre d’installation des parts
L’option develop
Option index et find-links
10.1 Définition
Un buildout est un dossier contenant plusieurs fichiers de configuration permettant de reproduire à l’identique un
environnement de développement ou de production. Paster est l’outil qui permet de générer le code squelette pour
démarrer.
109
Plone pour les intégrateurs, Version 1.0.0
10.2 Introduction
Buildout est un système d’installation permettant d’obtenir le même résultat d’une machine à l’autre. L’installation
est reproductible.
– Qu’est-ce que zc.buildout ?
– Survol de Buildout
zc.buildout permet d’avoir un environnement (pas forcément isolé), mais d’une autre manière que virtualenv.
Une configuration buildout spécifie un ensemble de parts qui se composent :
– d’une recette (recipe)
– et/ou de données de configuration
10.3 Organisation d’un buildout
Un buildout est organisé de la manière suivante :
– buildout.cfg : contient la configuration du buildout
– bootstrap.py : script d’amorçage de buildout utilisé la première fois
– bin/ : dossier contenant les exécutables éventuellement générés par les parts
– src/ : par convention, dossier où sont placés les eggs en développement
– parts/ : dossier où sont stockées les données générées des parts si besoin
– .installed.cfg : fichier caché mémorisant l’état du buildout
– .mr.developer.cfg : fichier caché mémorisant l’état des packages en développement si vous utilisez
l’extension mr.developer.
– eggs/ : dossier contenant les eggs activés ou non. Peut ne pas exister si on utilise un dossier partagé pour
plusieurs buildouts.
– develop-eggs/ : dossier contenant les liens vers les eggs en développement
– extends-cache/ si vous mettez en cache les fichiers de versions téléchargés.
Seuls les fichiers buildout.cfg, bootstrap.py et extends-cache/ ont besoin d’être mis dans une
gestionnaire de versions.
Nous allons prendre comme exemple le buildout.cfg pour installer archgenxml.
Suivez la page d’installation du manuel d’archgenxml2
Créez un dossier archgenxml_buildout/, placez y une copie du fichier bootstrap.py et créez un fichier
buildout.cfg avec le contenu suivant :
[buildout]
parts =
archgenxml
[archgenxml]
recipe = zc.recipe.egg:scripts
eggs = archgenxml
Note : Les versions de zc.buildout >= 1.5.2 permettent d’avoir un environnement isolé du système, cela est
désactivé par défaut pour garder la compatibilité avec les versions antérieures. Pour avoir pleinement cette
fonctionnalité, il faut que vous activiez l’option include-site-packages = false et que vous remplaciez zc.recipe.egg par z3c.recipe.scripts. Si vous utilisez d’autres recipes, il faut qu’elles utilisent aussi
z3c.recipe.scripts en interne. Regardez dans le changelog de ces recipes, s’il est indiqué que la recipe dépend
maintenant d’une version >= 1.5.0, c’est qu’elle a dû être adapté pour utiliser z3c.recipe.scripts.
10.4 Section principale [buildout]
La variable parts contient la liste des parts que buildout doit installer. La convention est de mettre une part par
ligne, indenté de 4 espaces. Il peut y avoir des lignes vides et des commentaires commencant au début de la ligne.
Chaque part fournit une variable recipe pour indiquer comment ce part doit être installé, mis à jour et supprimé.
110
Chapitre 10. Introduction à zc.buildout
Plone pour les intégrateurs, Version 1.0.0
Il se peut qu’une section ne fournisse pas de recipe. Elle sert généralement pour des données de configuration que
d’autres parts utiliseront.
Amorcez le buildout (choisissez bien la version de l’exécutable python) :
$ python bootstrap.py -d
Downloading http://pypi.python.org/packages/source/d/distribute/distribute-0.6.14.tar.gz
...
Creating directory ’/home/vincentfretin/archgenxml_buildout/bin’.
Creating directory ’/home/vincentfretin/archgenxml_buildout/parts’.
Creating directory ’/home/vincentfretin/archgenxml_buildout/eggs’.
Creating directory ’/home/vincentfretin/archgenxml_buildout/develop-eggs’.
Generated script ’/home/vincentfretin/archgenxml_buildout/bin/buildout’.
$ tree
.
|-- bin
|
‘-- buildout
|-- bootstrap.py
|-- buildout.cfg
|-- develop-eggs
|-- eggs
|
|-- distribute-0.6.14-py2.6.egg
|
‘-- zc.buildout-1.5.2-py2.6.egg
‘-- parts
‘-- buildout
|-- site.py
‘-- sitecustomize.py
L’amorçage (ou bootstrapping) installe distribute et zc.buildout. L’amorçage génère le script
bin/buildout.
Exécutez maintenant :
$ bin/buildout
Getting distribution for ’zc.recipe.egg’.
Got zc.recipe.egg 1.3.2.
Installing archgenxml.
Getting distribution for ’archgenxml’.
Got archgenxml 2.5.
...
Generated script ’/home/vincentfretin/archgenxml_buildout/bin/archgenxml’.
Generated script ’/home/vincentfretin/archgenxml_buildout/bin/agx_argouml_profile’.
Generated script ’/home/vincentfretin/archgenxml_buildout/bin/agx_stereotypes’.
Generated script ’/home/vincentfretin/archgenxml_buildout/bin/agx_taggedvalues’.
Le egg archgenxml et ses dépendances sont téléchargés et installés et divers scripts sont générés à la fin. C’est
la recipe qui dit tout ça.
À première vue, l’exécution de buildout pourrait se résumer à cet algorithme : pour chaque part de l’option parts
de la section [buildout], appeler la recipe associée au part.
Revenons à la ligne recipe = zc.recipe.egg :scripts. zc.recipe.egg est un egg à deux espaces
de nom et le scripts après les deux points est un entry point du groupe zc.buildout.
Si vous ne spécifiez pas de point d’entrée, un point d’entrée nommé default sera alors recherché dans l’egg.
Jetez un œil au setup.py de zc.recipe.egg :
entry_points = {’zc.buildout’: [’default = %s:Scripts’ % name,
’script = %s:Scripts’ % name,
’scripts = %s:Scripts’ % name,
’eggs = %s:Eggs’ % name,
’custom = %s:Custom’ % name,
’develop = %s:Develop’ % name,
10.4. Section principale [buildout]
111
Plone pour les intégrateurs, Version 1.0.0
]
},
Dans ce cas, nous serions arrivé au même résultat si nous avions mis l’une de ces lignes :
recipe
recipe
recipe
recipe
=
=
=
=
zc.recipe.egg
zc.recipe.egg:default
zc.recipe.egg:scripts
zc.recipe.egg:script
L’entry point scripts pointe vers la classe Scripts du package zc.recipe.egg.
Cette classe, comme toute recipe, contient une méthode install et update. Voir l’API des recettes
Le fichier caché .installed.cfg garde la configuration de la dernière exécution de buildout.
Lorsqu’une section a été supprimée de la configuration, cette partie sera désinstallée lors de la relance de
bin/buildout. Si une section a été mis à jour, cette partie sera réinstallée. Pour les nouvelles sections avec recipe, les parties seront installées.
Notre algorithme de tout à l’heure est maintenant :
– pour chaque part de l’option parts de la section [buildout] :
– installer la recipe du part ;
– récupérer l’entry point spécifié (default si non spécifié) depuis la recipe ;
– si le part est actuellement installé mais sa configuration a changé, appeler la méthode update() de l’entry
point ;
– si le part n’a pas encore été installé, appeler la méthode install() de l’entry point ;
– si un part existe dans .installed.cfg et n’est plus dans la liste des parts de [buildout], alors le part
est désintallé.
Jetez un œil sur les scripts générés. Rappel : les scripts bin/archgenxml et bin/agx_* sont générés car le
egg archgenxml a des entry points dans le groupe console_scripts. :
bin/archgenxml
#!/usr/bin/python
import sys
sys.path[0:0] = [
’/home/vincentfretin/archgenxml_buildout/eggs/archgenxml-2.5-py2.6.egg’,
...
]
import archgenxml.ArchGenXML
if __name__ == ’__main__’:
archgenxml.ArchGenXML.main()
La première ligne est le shebang, la version du python avec laquelle vous avez fait command :python bootstrap.py
-d au début. archgenxml et toutes ses dépendances sont ajoutés au début du sys.path.
10.5 Partage du dossier eggs et downloads
Lors de l’exécution de buildout, le fichier ~/.buildout/default.cfg est lu, c’est dans ce fichier que nous
pouvons mettre des options qui seront partagées par tous nos buildouts.
Si le dossier ~/.buildout/ n’existe pas, créez le ainsi que les sous-dossiers :
$ mkdir ~/.buildout ~/.buildout/eggs ~/.buildout/downloads \
~/.buildout/configs ~/.buildout/zope
Créez le fichier ~/.buildout/default.cfg avec ce contenu :
112
Chapitre 10. Introduction à zc.buildout
Plone pour les intégrateurs, Version 1.0.0
[buildout]
eggs-directory
download-cache
#extends-cache
zope-directory
=
=
=
=
/home/vincentfretin/.buildout/eggs
/home/vincentfretin/.buildout/downloads
/home/vincentfretin/.buildout/configs
/home/vincentfretin/.buildout/zope
Remplacez ici bien sûr vincentfretin par votre compte. Vous ne pouvez pas utiliser le caractère ~ ici.
L’option zope-directory permet de partager la même installation de Zope 2.10.x pour plusieurs buildouts
Plone 3.
À savoir que les valeurs par défaut de ces variables sont :
eggs-directory = ${buildout:directory}/eggs
download-cache = pas précisé, on ne garde pas les archives par défaut
extends-cache = pas de cache par défaut
${buildout :directory} étant le dossier du buildout. C’est pour cela que le dossier eggs était créé dans
le buildout.
Vous pouvez supprimer le dossier eggs de votre buildout, le réamorcer et reexécuté bin/buildout
10.6 Pinning des versions
À chaque fois que vous exécutez bin/buildout, une requête est faite au serveur central pour savoir si nous avons la
dernière version du egg. C’est le comportement par défaut. En effet nous avons l’option newest = true dans
la section [buildout] par défaut.
Vous pouvez faire bin/buildout -N pour ne pas vérifier les mises à jour.
Si vous aviez newest = false dans votre buildout, la commande bin/buildout -n la remettrait à true pour
l’exécution.
Le problème est que votre buildout n’est pas reproductible à l’identique. Pour qu’il soit reproductible à l’identique
il faudrait que votre buildout précise quelles versions des eggs doivent être installées.
C’est là qu’intervient l’option versions de la section [buildout], vous spécifiez dans quelle section vous
avez les informations sur les versions. La convention est de l’appeler également versions. Pour geler (verbe
“to pin” en anglais, “pinned” au participe passé) archgenxml, modifiez votre buildout de cette manière :
[buildout]
versions = versions
parts = archgenxml
[versions]
archgenxml = 2.5
# ...
[archgenxml]
recipe = zc.recipe.egg:scripts
eggs = archgenxml
Mais cela ne suffit pas pour que le buildout soit reproductible car nous n’avons pas gelé les dépendances d’archgenxml.
10.7 Extension buildout.dumppickedversions
zc.buildout peut être étendu avec des extensions. Il y en a une particulièrement intéressante qui va vous sortir
la liste des eggs qui ne sont pas gelés avec leur version.
10.6. Pinning des versions
113
Plone pour les intégrateurs, Version 1.0.0
Une extension s’ajoute avec l’option extensions de la section [buildout] Ajoutez donc l’extension
buildout.dumppickedversions à votre fichier ~/.buildout/default.cfg, comme cela l’extension sera active pour tous vos buildouts :
[buildout]
extensions = buildout.dumppickedversions
# ...
Relancez bin/buildout et à la fin de l’exécution vous verrez apparaitre la liste des versions à geler. Ajoutez-les
tous à votre section versions, et reexécutez bin/buildout, il ne devrait plus avoir de versions.
Il existe aussi une option allow-picked-versions = false disponible dans le cœur de
zc.buildout qui permet de stopper le buildout si un egg n’est pas gelé. Cette option et l’extension
buildout.dumppickedversions sont mutuellement exclusives.
10.8 Option extends
Il est possible d’étendre le fichier buildout.cfg. Vous verrez souvent un fichier deployment.cfg ou
development.cfg qui étend le fichier buildout.cfg de base.
Créez un fichier development.cfg :
[buildout]
extends = buildout.cfg
parts = omelette
[omelette]
recipe = collective.recipe.omelette
eggs = archgenxml
L’option extends dit de lire le fichier buildout.cfg, et les options que l’on spécifiera par la suite seront
écrasées.
Par défaut, buildout cherche un fichier buildout.cfg, l’option -c permet d’indiquer un fichier alternatif.
Relancez la machinerie buildout avec ce fichier :
$ bin/buildout -c development.cfg
Uninstalling archgenxml.
Installing omelette.
Oh que s’est-il passé ? Vous avez écrasé l’option parts, il n’y a donc plus que le part omelette à installer.
Vous vouliez garder aussi le part archgenxml, rectifiez ça en transformant le = par +=, ce qui donne parts
+= omelette.
Toutes les options supportant une liste fonctionnent ainsi (parts, eggs, develop).
Relancez buildout. Là les deux parts sont bien installées.
Remarque
imaginez toujours que vous avez implicitement extends = ~/.buildout/default.cfg dans votre
buildout.cfg de base, à partir duquel vous étendez d’autres configurations, ici c’est le fichier
buildout.cfg.
Vous pouvez récupérer une version mis à plat de la configuration avec la commande suivante :
$ bin/buildout -c development.cfg annotate
...
[buildout]
parts=
archgenxml
omelette
114
Chapitre 10. Introduction à zc.buildout
Plone pour les intégrateurs, Version 1.0.0
/home/vincentfretin/archgenxml_buildout/buildout.cfg
+= /home/vincentfretin/archgenxml_buildout/development.cfg
...
Vous voyez bien ici que l’option parts a été mis à plat, c’est la concaténation de l’option trouvée dans
buildout.cfg et de development.cfg.
10.8.1 Option extends-cache
L’option extends-cache disponible depuis la version 1.4.0 de zc.buildout permet de mettre en cache les
fichiers référencés dans l’option extends.
Prenons l’exemple suivant :
extends = http://dist.plone.org/release/4.0.1/versions.cfg
Le fichier versions.cfg sera mis en cache dans le dossier ~/.buildout/configs/, le fichier créé étant
la somme md5 de l’url.
Une fois mis en cache, il est possible de relancer le buildout en mode hors ligne avec la commande bin/buildout
-o.
10.9 Recipe collective.recipe.omelette
On ne fait pas d’omelette sans casser des eggs. Cette recipe permet de mettre à plat les eggs :
[omelette]
recipe = collective.recipe.omelette
eggs = archgenxml
Cette recipe génère une arborescence dans parts/omelette/ contenant archgenxml et toutes ses dépendances
directes ou indirectes :
$ tree parts/omelette/
parts/omelette
|-- archgenxml -> /home/vincentfretin/.buildout/eggs/archgenxml-2.5-py2.6.egg/archgenxml
|-- easy_install.py -> /usr/local/lib/python2.6/dist-packages/distribute-0.6.14-py2.6.egg/easy_ins
|-- i18ndude -> /home/vincentfretin/.buildout/eggs/i18ndude-3.2-py2.6.egg/i18ndude
|-- pkg_resources.py -> /usr/local/lib/python2.6/dist-packages/distribute-0.6.14-py2.6.egg/pkg_res
|-- plone
|
|-- __init__.py
|
‘-- i18n -> /home/vincentfretin/.buildout/eggs/plone.i18n-2.0-py2.6.egg/plone/i18n
|-- setuptools -> /usr/local/lib/python2.6/dist-packages/distribute-0.6.14-py2.6.egg/setuptools
|-- site.py -> /usr/local/lib/python2.6/dist-packages/distribute-0.6.14-py2.6.egg/site.py
|-- stripogram -> /home/vincentfretin/.buildout/eggs/stripogram-1.5-py2.6.egg/stripogram
|-- xmiparser -> /home/vincentfretin/.buildout/eggs/xmiparser-1.5-py2.6.egg/xmiparser
‘-- zope
|-- __init__.py
|-- browser -> /home/vincentfretin/.buildout/eggs/zope.browser-1.3-py2.6.egg/zope/browser
|-- component -> /home/vincentfretin/.buildout/eggs/zope.component-3.10.0-py2.6.egg/zope/compo
|-- configuration -> /home/vincentfretin/.buildout/eggs/zope.configuration-3.7.2-py2.6.egg/zop
|-- contenttype -> /home/vincentfretin/.buildout/eggs/zope.contenttype-3.5.1-py2.6.egg/zope/co
|-- documenttemplate -> /home/vincentfretin/.buildout/eggs/zope.documenttemplate-3.4.2-py2.6.e
|-- event -> /home/vincentfretin/.buildout/eggs/zope.event-3.5.0_1-py2.6.egg/zope/event
|-- exceptions -> /home/vincentfretin/.buildout/eggs/zope.exceptions-3.6.1-py2.6.egg/zope/exce
|-- i18n -> /home/vincentfretin/.buildout/eggs/zope.i18n-3.7.4-py2.6.egg/zope/i18n
|-- i18nmessageid -> /home/vincentfretin/.buildout/eggs/zope.i18nmessageid-3.5.3-py2.6-linux-x
|-- interface -> /home/vincentfretin/.buildout/eggs/zope.interface-3.6.1-py2.6-linux-x86_64.eg
|-- location -> /home/vincentfretin/.buildout/eggs/zope.location-3.9.0-py2.6.egg/zope/location
|-- proxy -> /home/vincentfretin/.buildout/eggs/zope.proxy-3.6.1-py2.6-linux-x86_64.egg/zope/p
10.9. Recipe collective.recipe.omelette
115
Plone pour les intégrateurs, Version 1.0.0
|-|-|-|-‘--
publisher -> /home/vincentfretin/.buildout/eggs/zope.publisher-3.12.4-py2.6.egg/zope/publi
schema -> /home/vincentfretin/.buildout/eggs/zope.schema-3.7.0-py2.6.egg/zope/schema
security -> /home/vincentfretin/.buildout/eggs/zope.security-3.7.4-py2.6-linux-x86_64.egg/
structuredtext -> /home/vincentfretin/.buildout/eggs/zope.structuredtext-3.5.0-py2.6.egg/z
tal -> /home/vincentfretin/.buildout/eggs/zope.tal-3.5.2-py2.6.egg/zope/tal
25 directories, 5 files
Cela permet d’avoir les packages à plat, ce qui facilite la recherche, exemple :
$ find -L parts/omelette -name "interfaces.py"
$ grep -r "register" parts/omelette
Si vous développez avec Eclipse/Pydev, vous pouvez ajouter le répertoire parts/omelette/ au PYTHONPATH du projet, ceci permet l’exploration du code en mode “hypertexte” (ctrl+clic sur un symbole) et l’auto
completion intelligente de fonctionner correctement.
10.10 Utilisation de variable
Vous avez écrit “archgenxml” à deux endroits, une fois dans la recipe zc.recipe.egg et une autre fois dans la
recipe collective.recipe.omelette. Il est plus intéressant de l’indiquer une seule fois dans une variable
et d’utiliser cette variable ensuite dans les recipes.
Une convention est de définir une variable eggs dans la section [buildout] et de récupérer cette variable avec
${buildout :eggs}.
Voici ce que donnent les deux fichiers une fois reécrits.
buildout.cfg
[buildout]
versions = versions
parts = archgenxml
eggs = archgenxml
[versions]
archgenxml = 2.5
distribute = 0.6.14
xmiparser = 1.5
zc.buildout = 1.5.2
zc.recipe.egg = 1.3.2
zope.contenttype = 3.5.1
zope.i18nmessageid = 3.5.3
zope.tal = 3.5.2
Unidecode = 0.04.1
i18ndude = 3.2
ordereddict = 1.1
plone.i18n = 2.0
pytz = 2010l
stripogram = 1.5
zope.browser = 1.3
zope.component = 3.10.0
zope.configuration = 3.7.2
zope.documenttemplate = 3.4.2
zope.event = 3.5.0-1
zope.exceptions = 3.6.1
zope.i18n = 3.7.4
zope.interface = 3.6.1
zope.location = 3.9.0
zope.proxy = 3.6.1
zope.publisher = 3.12.4
116
Chapitre 10. Introduction à zc.buildout
Plone pour les intégrateurs, Version 1.0.0
zope.schema = 3.7.0
zope.security = 3.7.4
zope.structuredtext = 3.5.0
[archgenxml]
recipe = zc.recipe.egg:scripts
eggs = ${buildout:eggs}
development.cfg
[buildout]
extends = buildout.cfg
parts += omelette
[omelette]
recipe = collective.recipe.omelette
eggs = ${buildout:eggs}
Vous pouvez référencer n’importe quelle variable de la section que vous souhaitez avec
${nomdesection :variable}. Vous pouvez référencer une variable de la même section avec juste
${ :variable}.
10.11 Repinning et fusion de section de données
Vous voyez que la recipe collective.recipe.omelette n’est pas gelé. Faites donc les modifications
suivantes dans development.cfg :
[buildout]
# ...
versions = vers
[vers]
collective.recipe.omelette = 0.9
Relancez buildout. Vous voyez que seul collective.recipe.omelette est gelé maintenant car l’option
versions a été écrasée.
Renommez vers en versions et relancez le buildout.
Tous les eggs sont gélés. En effet la section versions de buildout.cfg et la section versions de
development.cfg ont fusionné.
En conclusion, nommez toujours versions la section contenant les versions.
Mais maintenir deux listes est source d’erreur. Créez un fichier versions.cfg qui contient une section
[versions] (pas de section [buildout]), et dites à buildout.cfg d’étendre versions.cfg. Relancez buildout pour voir que tout fonctionne.
10.12 Ordre d’installation des parts
L’ordre d’installation des parts n’est pas forcément l’ordre donné dans l’option parts de [buildout]. Et une
part peut très bien être installée si elle n’est pas listée dans parts.
Modifiez votre buildout.cfg comme ceci :
[buildout]
# ...
parts = zopeskel archgenxml
[archgenxml]
10.11. Repinning et fusion de section de données
117
Plone pour les intégrateurs, Version 1.0.0
# ...
packages = ZopeSkel
[zopeskel]
recipe = zc.recipe.egg
eggs = ${archgenxml:packages}
Dans cet exemple, il n’y aucune raison particulière pour installer une part avant l’autre. C’est juste pour l’exercice.
L’ordre d’installation sera [archgenxml], puis [zopeskel]. Si maintenant vous supprimez la part
[archgenxml] de parts, elle sera toujours installée car la part [zopeskel] en dépend, faisant référence à
une de ses variables.
10.13 L’option develop
Note : Cette partie dépend du chapitre Concept de Python eggs.
L’option develop permet d’indiquer quels eggs sont en mode développement.
Créez un dossier src/ et déplacez y vos deux eggs foo.bar et foo.rab.
Ajoutez foo.bar à l’omelette et relancez bin/buildout -c development.cfg. Buildout tente d’aller
chercher foo.bar sur Pypi et échoue.
Nous allons donc lui dire où le trouver.
Ajoutez à la section [buildout] de development.cfg :
[buildout]
# ...
develop = src/foo.bar
Relancez bin/buildout -c development.cfg.
Le egg foo.bar est en mode développement :
$ ls -l develop-eggs/
total 12
-rw-r--r-- 1 vincentfretin vincentfretin 57 2009-05-26 18:20 foo.bar.egg-link
-rw-r--r-- 1 vincentfretin vincentfretin 32 2009-05-26 15:38 setuptools.egg-link
Nous pouvons également utiliser un wildcard dans l’option develop. Mettez develop = src/*, du coup les
deux eggs foo.bar et mod :foo.rab sont en développement.
10.14 Option index et find-links
Note : Cette partie dépend du chapitre Concept de Python eggs.
L’option index permet de spécifier un autre index que celui par défaut, par exemple un pypi proxy avec
collective.eggproxy.
L’option find-links permet d’indiquer des liens supplémentaires où l’on peut trouver les eggs utilisés dans le
buildout.
Nous allons maintenant installer foo.bar = 1.0, la release qu’il y a sur notre pypi.
Supprimez donc l’option develop et dans development.cfg, ajoutez :
[buildout]
# ...
find-links += http://devagile:8080/site/products/simple
118
Chapitre 10. Introduction à zc.buildout
Plone pour les intégrateurs, Version 1.0.0
et dans versions.cfg, ajoutez foo.bar = 1.0.
10.14. Option index et find-links
119
Plone pour les intégrateurs, Version 1.0.0
120
Chapitre 10. Introduction à zc.buildout
CHAPITRE 11
Installation et création d’une instance
Plone
– Savoir
– Installation via l’Unified Installer
– Installation via un template buildout
– Installation sous Ubuntu/Debian
– Installation sur Windows
– Installation sous Mac OSX
– Exercice
Plusieurs types d’installation sont possibles, soit en utilisant un “template” de configuration, soit en utilisant un
unified installer.
11.1 Savoir
La récupération des archives et leur installation, la création d’un buildout et la compilation de Zope.
Plone est disponible en plusieurs versions et selon différents modes.
Note à propos des combinaisons de versions de Plone, Python et Zope :
– Plone 3.3 utilise Python 2.4, Zope 2.10. Python 2.5 et 2.6 ne sont pas supportés.
– Plone 4 utilise Python 2.6 et Zope 2.12.
– Plone 4.1 utilise Zope 2.13, Python 2.7 est supporté.
11.1.1 Installation via l’Unified Installer
C’est la solution la plus simple.
Le unified installer est un paquet qui contient toutes les sources, bibliothèques et outils nécessaires à l’exécution
de Plone.
Il contient aussi un script d’installation qui permet de configurer Plone.
Il contient le mécanisme buildout qui permettra de facilement modifier la configuration de Plone pour ajouter des
modules tierces.
Pour l’installer, il suffit de récupérer le paquet sur http ://plone.org/products/plone et d’exécuter ou d’extraire le
paquet selon sa plateforme.
Commandes à exécuter :
121
Plone pour les intégrateurs, Version 1.0.0
$
$
$
$
$
$
wget http://launchpad.net/plone/3.3/3.3.X/+download/Plone-3.3.X-UnifiedInstaller.tgz
tar xvzf Plone-3.3rc3-UnifiedInstaller.tgz
cd Plone-3.3rc3-UnifiedInstaller
./install.sh --with-python=/usr/bin/python2.4 standalone
cd ~/Plone/zinstance
bin/plonectl start
Le mode standalone crée une seule instance. Vous pouvez remplacer standalone par zeo pour créer deux
clients avec un zeoserver.
Si vous lancez le script en root, il créera un utilisateur plone et installera Python, Zope et Plone dans
/usr/local/Plone. Python ne sera pas compilé si vous utilisez l’option --with-python.
Pour plus d’informations, lisez le fichier README.txt dans l’archive et la documentation Installing Plone 3 with
the Unified Installer sur plone.org
L’inconvénient de cette solution est que les paquets unified installer sont réalisés pour les versions stables ou beta
de Plone. Les impatients doivent suivre la procédure d’installation par buildout.
11.1.2 Installation via un template buildout
Buildout est un outil qui permet de créer et déployer des configurations de projets Python.
Il est possible à partir d’un outil nommé paster de créer un squelette de configuration pour buildout. Cet outil sera
aussi détaillé par la suite, il se repose sur un mécanisme de patrons (template) propre à chaque projet.
Pour installer une version de Plone donnée (depuis la version 2.5), il suffit donc de créer une configuration pour la
version de Plone voulue en utilisant paster puis de compléter cette configuration pour enfin la construire.
L’intérêt de cette méthode est de permettre l’installation de version en cours de développement ou en vue d’automatiser le déploiement sur plusieurs serveurs.
Installation sous Ubuntu/Debian
Installez tout d’abord quelques packages de développement qui seront nécessaires pour compiler PIL (Imaging)
et python-libxml2 :
$ apt-get install libxml2-dev libjpeg62-dev libfreetype6-dev zlib1g-dev
– libxml2-dev pour compiler python-libxml2
– libjpeg62-dev libfreetype6-dev zlib1g-dev pour compiler PIL
Dans Ubuntu Jaunty Jackalope 9.04 et suivants, les versions de Python installés par défaut sont 2.5 et 2.6.
Et les packages python-imaging et python-libxml2 de la distribution ne sont compilés que pour ces versions.
Il n’y a donc plus de support de ces packages pour Python 2.4. C’est pourquoi ces deux bibliothèques seront
compilées à partir du buildout.
Voir le billet de Maurits van Rees à ce sujet
Continuez sur le chapitre Création d’un buildout Plone avec ZopeSkel.
Installation sur Windows
Cette section est une mise à jour pour Plone 4 et une francisation de http ://plone.org/documentation/kb/usingbuildout-on-windows
Beaucoup de données vont être téléchargées vous devez donc avoir une connexion rapide.
Vous devez être à l’aise avec Windows et sa console Dos.
Nous réaliserons l’installation de Plone 4, mais l’installation de Plone 3 est la même à la différence qu’au lieu
d’utiliser Python2.6 vous utiliserez Python2.4 :
122
Chapitre 11. Installation et création d’une instance Plone
Plone pour les intégrateurs, Version 1.0.0
Python
Installer Python via le msi installer en le téléchargeant depuis le site http ://python.org, sélectionner “install for all
users” qui créera le répertoire c :\Python26 par défaut.
Changer la variable d’environnement path pour que Windows puisse automatiquement associer la commande
python à l’environnement :
– Python 2.6. Pour cela ouvrez Le panneau de configuration → Les Propriétés système → Variables d’environnement → Path → Modifier
– Ajoutez y en fin ;c :\Python26 ;c :\Python26\Scripts.
– Vérifier que vos modifications sont bien prises en compte en ouvrant une invite de commandes en saisissant
python -V qui doit vous afficher la version de Python.
Distribute
– Télécharger le gestionnaire de paquet Python distribute à l’adresse http ://pythondistribute.org/distribute_setup.py ce qui permettra de récupérer les bibliothèques tierces nécessaire à
Plone.
– Exécuter le dans l’environnement Python correspondant à votre distribution Plone :
c:\Python26\python.exe distribute_setup.py
pywin32
– Installer l’extension pywin32 qui permettra d’utiliser les applications Windows dans Python. Elle est disponible à l’adresse http ://sourceforge.net/projects/pywin32/files. Installer la version la plus récente proposée pour
Python 2.6.
PIL
– Installer PIL la bibliothèque de traitement d’image dont a besoin Plone pour retailler les images importées,
disponible à l’adresse http ://effbot.org/downloads :
http ://effbot.org/downloads/PIL-1.1.7.win32-py2.6.exe
Des
installeurs
pour
PIL
et
votre
http ://www.pythonware.com/products/pil/
version
de
Python
sont
disponibles
ici
:
Des installeurs pour les bindings Python libxml2 et libxslt pré-compilés sont mis à votre disposition ici :
http ://users.skynet.be/sbi/libxml-python/
Subversion
Installation de subversion. Subversion est un système de gestion de version qui permet de conserver et de réaliser
des différences entre les évolutions d’un programme.
La communauté Plone l’utilise pour gérer le code source de Plone.
Ainsi, nous récupèrerons les fichiers nécessaires à la configuration du buildout.
– Nous allons donc le télécharger et l’installer :
http ://subversion.tigris.org/files/documents/15/45953/Setup-Subversion-1.6.2.msi
– Puis nous ajoutons à notre variable d’environnement Path le chemin vers subversion :
c:\Program Files\Subversion\bin
– Vérifier en entrant la commande svn –version dans Invite de commandes que vous avez bien une version 1.6.2
11.1. Savoir
123
Plone pour les intégrateurs, Version 1.0.0
F IG . 11.1 – Modification du path
124
Chapitre 11. Installation et création d’une instance Plone
Plone pour les intégrateurs, Version 1.0.0
MinGW
Installation de MinGW. MinGW est un portage du compilateur gcc pour Windows. Nous pourrons ainsi compiler
le code C de Zope.
– Récupérer le sur http ://sourceforge.net/projects/mingw/files/
– Exécuter
– Choisir download and install
– Accepter la licence
– Prendre la version actuelle
– Cocher MinGW base tools et MinGW Make
– Installer MinGW dans c :\MinGW et faire suivant
– MinGW télécharge les outils nécessaires
– Ajouter C :\MinGW\bin au Path
– Copier cc1.exe et collect2.exe du répertoire c :\MinGW\libexec\gcc\mingw32\3.4.5 dans
C :\MinGW\bin
– Vérifier en entrant gcc –version dans l’invite de commande
– Vérifier qu’il existe un fichier libpython26.a dans C :\Python26\libs sinon suivez la procédure
décrite à http ://www.python.org/doc/2.4.1/inst/tweak-flags.html#SECTION000622000000000000000
– Si vous utilisez Python depuis une installation de Plone, vous devez copier
– Plone\Python\PC\pyconfig.h vers Plone\Python\Include
Configuration de Distutils pour utiliser MinGW
Nous allons créer un fichier de configuration qui permettra à distutils de savoir qu’il doit compiler les fichiers avec
MinGW.
Enregistrez les lignes suivantes dans C :\Python26\Lib\distutils\distutils.cfg :
[build]
compiler=mingw32
Installation de paster
Paster va nous permettre de créer le squelette de déploiement de notre site Plone. Il sera détaillé dans le chapitre
qui lui est consacré.
Pour installer Paster il suffit de faire easy_install PasteScript
Pour vérifier qu’il a bien été installé nous pouvons afficher les patrons de projets existant par défaut :
C:\>paster create --list-templates
Available templates:
basic_package: A basic setuptools-enabled package
paste_deploy:
A web application deployed through paste.deploy
Qui n’affiche que deux types de patron.
Nous allons ajouter les patrons liés aux projets Zope avec la commande easy_install ZopeSkel et vérifier les
patrons disponibles :
C:\>paster create --list-templates
Available templates:
archetype:
A Plone project that uses Archetypes content types
basic_namespace:
A basic Python project with a namespace package
basic_package:
A basic setuptools-enabled package
basic_zope:
A Zope project
kss_plugin:
A project for a KSS plugin
nested_namespace:
A basic Python project with a nested namespace (2 dots
in name)
11.1. Savoir
125
Plone pour les intégrateurs, Version 1.0.0
paste_deploy:
plone:
plone2.5_buildout:
plone2.5_theme:
plone2_theme:
plone3_buildout:
plone3_portlet:
plone3_theme:
plone_app:
dots in name)
plone_hosting:
plone_pas:
recipe:
silva_buildout:
A
A
A
A
A
A
A
A
A
web application deployed through paste.deploy
project for Plone products
buildout for Plone 2.5 projects
theme for Plone 2.5
theme for Plone 2.1
buildout for Plone 3 installation
Plone 3 portlet
theme for Plone 3
project for Plone products with a nested namespace (2
Plone hosting: buildout with ZEO and any Plone version
A project for a Plone PAS plugin
A recipe project for zc.buildout
A buildout for Silva projects
Installation de Plone 4
Nous allons procéder à l’installation de Plone en créant un buildout spécifique.
Pour cela saisissez la commande paster create -t plone3_buildout monplone4. Pour l’instant on utilise le patron de Plone 3 pour un site Plone 4. En indiquant une version supérieure ou égale à 4, la génération du fichier
buildout.cfg sera différente d’un Plone 3. Répondez aux questions comme ceci :
Expert mode ? expert
Plone version : 4.0b1-1
Zope2 Install Path :
Plone Products Directory :
Initial Zope Username [’admin’] :
Initial User Password : admin
HTTP Port [’8080’] : 9080
debug mode |’off’] :
verbose mode [’off’] :
Nous avons volontairement changé le port de Plone pour pouvoir faire cohabiter plusieurs versions ensemble.
La plupart de ces variables peuvent être changées par la suite.
L’exécution a pour conséquence de créer l’arborescence suivante :
C:\Documents and Settings\utlisateur>dir monplone4
Le volume dans le lecteur C n’a pas de nom.
Le numéro de série du volume est BC6D-1497
Répertoire de C:\Documents and Settings\utlisateur\monplone4
15/03/2010
15/03/2010
15/03/2010
15/03/2010
15/03/2010
15/03/2010
15/03/2010
15/03/2010
23:26
<REP>
.
23:26
<REP>
..
23:26
3 901 bootstrap.py
23:26
2 285 buildout.cfg
23:26
<REP>
products
23:26
10 856 README.txt
23:26
<REP>
src
23:26
<REP>
var
3 fichier(s)
17 042 octets
5 Rép(s)
8 233 197 568 octets libres
Nous allons générer les scripts de génération :
C:\Documents and Settings\utlisateur>cd monplone4
C:\Documents and Settings\utlisateur\monplone4>python bootstrap.py
Creating directory ’C:\\Documents and Settings\\utlisateur\\monplone4\\bin’
126
Chapitre 11. Installation et création d’une instance Plone
Plone pour les intégrateurs, Version 1.0.0
Creating directory ’C:\\Documents and Settings\\utlisateur\\monplone4\\parts’
Creating directory ’C:\\Documents and Settings\\utlisateur\\monplone4\\eggs’
Creating directory ’C:\\Documents and Settings\\utlisateur\\monplone4\
\develop-eggs’
Generated script ’C:\\Documents and Settings\\utlisateur\\monplone4\\bin\
\buildout’
Nous allons provoquer la récupération, la compilation et l’installation de Zope et Plone :
C:\Documents and Settings\utlisateur\monplone4>.\bin\buildout.exe
Getting distribution for ’plone.recipe.distros’.
zip_safe flag not set; analyzing archive contents...
plone.__init__: module references __path__
plone.recipe.__init__: module references __path__
Got plone.recipe.distros 1.5.
Getting distribution for ’plone.recipe.zope2instance==4.0a4’.
Got plone.recipe.zope2instance 4.0a4.
Getting distribution for ’Zope2==2.12.3’.
...
Generated script ’C:\\Documents and Settings\\utlisateur\\monplone4\\bin\
\instance’.Installing zopepy.
Generated interpreter ’C:\\Documents and Settings\\utlisateur\\monplone4\
\bin\\zopepy’.
Si tout ce passe bien nous avons un répertoire bin qui contient les lanceurs.
Pour démarrer Plone :
C:\Documents and Settings\utlisateur\monplone4>bin\instance.exe fg
Création de l’instance
Connectez vous à l’adresse http ://localhost :8080, on vous propose de créer un site Plone. Allez y.
Remarques
L’installation de plone via buildout pour Windows, n’est pas recommandée par la communauté en raison de sa
complexité.
Pour Windows, il vaut mieux passer par unified installer qui possèdera une installation de Python, un PIL, un
Zope, et un buildout prêt à l’emploi.
Ce qui correspond à une installation réussie des étapes précédentes...
Dans les deux cas, l’ajout des modules à Plone (anciennement appelés produit) se fait par ajout d’un egg.
Les eggs sont désormais la forme standard des paquets contenant les modules d’extensions de Plone.
Nous détaillerons les eggs dans un autre chapitre.
Donc l’ajout d’un egg se fait par déclaration du nom du egg voulu dans le fichier buildout.cfg à la section
eggs.
En lançant la commande bin\buildout.exe, le egg sera téléchargé, et au prochain démarrage de Plone, il y sera
accessible dans la liste des modules du menu de configuration de Plone.
Installation sous Mac OSX
Sous Mac OSX, installez Python 2.4 soit avec le bundle Python 2.4 .dmg proposé en téléchargement, soit en
utilisant MacPorts,
11.1. Savoir
127
Plone pour les intégrateurs, Version 1.0.0
Si vous avez installé Python avec MacPorts, pas de problème :
$ sudo port install py-pil
$ sudo port install py-libxml2
$ sudo port install py-libxslt
Autrement,
vous
pouvez
trouver
une
version
http ://pythonmac.org/packages/py25-fat/index.html
pré-compilée
statique
de
PIL
ici
:
Et vous devrez compilez les binders libxml2 et libxslt ceci sur votre poste comme indiqué ici : http ://jamesclarke.net/notes/libxml2
Suivez ensuite la procédure pour Ubuntu/Debian.
11.2 Exercice
Nous allons créer l’instance de test qui sera utilisée dans les exercices suivants.
128
Chapitre 11. Installation et création d’une instance Plone
CHAPITRE 12
Création d’un buildout Plone avec
ZopeSkel
Author Vincent Fretin
Contributors
Version 1.0.0
Révision https ://svn.plone.org/svn/collective/collective.trainingmanual/trunk/fr/integrateur/source/presentation_plone.txt
Copyright (C) 2010 Vincent Fretin <vincentfretin AT ecreall.com>.
Chacun est autorisé à copier, distribuer et/ou modifier ce document suivant les termes de la licence
Paternité-Pas d’Utilisation Commerciale-Partage des Conditions Initiales à l’Identique 2.0 France accessible à
http ://creativecommons.org/licenses/by-nc-sa/2.0/fr
Le code source présent dans ce document est soumis aux conditions de la « Zope Public License », Version 2.1
(ZPL).
THE SOURCE CODE IN THIS DOCUMENT AND THE DOCUMENT ITSELF IS PROVIDED “AS IS” AND
ANY AND ALL EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT,
AND FITNESS FOR A PARTICULAR PURPOSE.
– Création du buildout
– Installation de produits tierces
– Création d’un policy package contenant la configuration du site Plone
– Création du policy package
– Installation de Products.Collage à l’installation de formation.policy
– Déclaration de formation.policy comme plugin Plone
– Installation de Products.FCKeditor à l’installation de formation.policy
– Configuration de FCKeditor pour tous les nouveaux utilisateurs
– À propos des versions
– Releaser le policy package
– Repasser au développement
– Utilisation de mr.developer pour gérer les composants en développement
– Fabric
– Ressources
Note : Ce chapitre utilise un dépôt subversion créé dans le chapitre La gestion des sources avec subversion ainsi
qu’un Pypi privé créé via Mise en place d’un Pypi privé avec PloneSoftwareCenter.
129
Plone pour les intégrateurs, Version 1.0.0
12.1 Création du buildout
Créez les répertoires buildouts et packages sur le dépôt subversion :
$ svn mkdir http://devagile/Formation/buildouts
$ svn mkdir http://devagile/Formation/packages
Commandes :
$ paster create -t plone3_buildout plone4 --svn-repository=http://devagile/Formation/buildouts/
Selected and implied templates:
ZopeSkel#plone3_buildout A buildout for Plone 3 installation
Variables:
egg:
plone4
package: plone4
project: plone4
Running:
svn mkdir ...
Expert Mode? (What question mode would you like? (easy/expert/all)?) [’easy’]:
Plone Version (Plone version # to install) [’3.3.5’]: 4.0.1
Zope2 Install Path (Path to Zope2 installation; leave blank to fetch one!) [’’]:
Plone Products Directory (Path to Plone products; leave blank to fetch [Plone 3.0/3.1 only]) [’’]:
Initial Zope Username (Username for Zope root admin user) [’admin’]:
Initial User Password (Password for Zope root admin user) [’’]: admin
HTTP Port (Port that Zope will use for serving HTTP) [’8080’]:
Debug Mode (Should debug mode be "on" or "off"?) [’off’]:
Verbose Security? (Should verbose security be "on" or "off"?) [’off’]:
Creating template plone3_buildout
Copying README.txt to ./plone4/README.txt
Copying bootstrap.py to ./plone4/bootstrap.py
Copying buildout.cfg_tmpl to ./plone4/buildout.cfg
Recursing into products
Creating ./plone4/products/
Copying README.txt to ./plone4/products/README.txt
Recursing into src
Creating ./plone4/src/
Copying README.txt to ./plone4/src/README.txt
Recursing into var
Creating ./plone4/var/
Copying README.txt to ./plone4/var/README.txt
**************************************************************************
Generation finished.
**
**
**
You probably want to run python bootstrap.py and then edit
buildout.cfg before running bin/buildout -v".
** See README.txt for details.
**************************************************************************
Note : Avec l’option –svn-directory, un bug connu de Paste-1.7.3 et ZopeSkel-2.16 produit l’erreur suivante à la
fin du processus :
IOError : No egg-info directory found
Vous pouvez simplement l’ignorer.
Vous allez éditer un peu le fichier buildout.cfg avant d’amorcer le buildout.
Créez un fichier versions.cfg que vous utiliserez pour geler les versions des modules, pour l’instant vide :
[versions]
130
Chapitre 12. Création d’un buildout Plone avec ZopeSkel
Plone pour les intégrateurs, Version 1.0.0
Dans buildout.cfg, modifiez la variable extends en :
[buildout]
# ...
extends =
http://dist.plone.org/release/4.0.1/versions.cfg
versions.cfg
Si vous voulez travailler sur la dernière version du fichier versions.cfg de Plone, vous pouvez le télécharger comme
ceci :
$ svn cat \
http://svn.plone.org/svn/plone/buildouts/plone-coredev/branches/4.0/versions.cfg \
> versions-plone.cfg
et changez votre buildout.cfg pour que l’option extends ressemble à ceci :
extends =
versions-plone.cfg
versions.cfg
Ajoutez :
[buildout]
# ...
eggs =
PIL
PIL est téléchargé depuis http ://dist.plone.org/thirdparty. L’archive PIL téléchargeable sur pypi.python.org n’est
pas easy_installable.
La section [productdistros] est utilisée pour installer des produits Zope non encore eggifiés, rares de nos
jours.
Le buildout.cfg minimal que vous devez obtenir :
[buildout]
parts =
instance
zopepy
extends =
http://dist.plone.org/release/4.0.1/versions.cfg
versions.cfg
versions = versions
find-links =
http://dist.plone.org/release/4.0.1
http://dist.plone.org/thirdparty
eggs = PIL
develop =
[instance]
recipe = plone.recipe.zope2instance
user = admin:admin
http-address = 8080
eggs =
Plone
${buildout:eggs}
environment-vars =
zope_i18n_compile_mo_files true
zcml =
[zopepy]
recipe = zc.recipe.egg
eggs = ${instance:eggs}
12.1. Création du buildout
131
Plone pour les intégrateurs, Version 1.0.0
interpreter = zopepy
scripts = zopepy
Amorcez et lancez buildout :
$ cd plone4
$ python2.6 bootstrap.py -d
$ bin/buildout
$ ls -F
bin/
buildout.cfg
bootstrap.py develop-eggs/
$ ls parts
buildout instance
$ ls bin
buildout instance zopepy
parts/ README.txt
products/ src/
var/
versions.cfg
– instance : script pour contrôler l’instance zope
– zopepy : interpréteur python avec l’ensemble des eggs dans le sys.path
Démarrez l’instance avec bin/instance fg et connectez vous à http ://localhost :8080 pour créer votre site
Plone.
Note : Commitez votre buildout
$ svn ci -m"Created initial buildout structure"
12.2 Installation de produits tierces
Prenons le produit FCKeditor comme exemple.
Stoppez l’instance avec Ctrl+C.
Ajoutez Products.FCKeditor dans l’option eggs de la section [instance] et reexécutez le buildout :
$ bin/buildout
Démarrez l’instance :
$ bin/instance fg
Pour les produits n’étant pas dans l’espace de nom (namespace en anglais) Products, il faut également l’ajouter
dans l’option zcml.
À moins que le produit se proclame plugin Plone comme c’est le cas des modules créés avec la commande paster
que vous verrez dans la suite. Dans ce cas-là les fichiers zcml seront inclus grâce à z3c.autoinclude.
12.3 Création d’un policy package contenant la configuration du
site Plone
Vous allez créer un policy package contenant la configuration du site Plone.
Dans ce policy package, nous allons aussi dire d’installer automatiquement les produits Products.Collage
et Products.FCKeditor lors de l’installation du produit.
Nous allons ensuite configurer FCKeditor comme éditeur par défaut pour les utilisateurs nouvellement créés.
132
Chapitre 12. Création d’un buildout Plone avec ZopeSkel
Plone pour les intégrateurs, Version 1.0.0
12.3.1 Création du policy package
Créez le policy package :
$ cd /tmp/
$ paster create -t plone formation.policy \
--svn-repository=http://devagile/Formation/packages
Expert Mode? (What question mode would you like? (easy/expert/all)?) [’easy’]:
Version (Version number for project) [’1.0’]:
Description (One-line description of the project) [’’]: Projet exemple pour la formation integrate
Register Profile (Should this package register a GS Profile) [False]: True
$ cd formation.policy
$ svn rm --force formation.policy.egg-info
$ svn ci -m "Add initial structure for formation.policy"
Le template plone hérite du template basic_namespace, il ajoute en plus un fichier configure.zcml.
Vous allez utiliser la propriété svn :externals pour faire une sorte de checkout de votre nouveau package
dans le dossier src :
$ cd ~/workspace/plone4/src/
$ vim EXTERNALS.txt
formation.policy http://devagile/Formation/packages/formation.policy/trunk
$ svn propset svn:externals -F EXTERNALS.txt .
$ svn up
$ svn add EXTERNALS.txt
$ svn ci -m"Set svn:externals on src directory to install formation.policy"
Ajoutez Products.Collage et Products.FCKeditor en dépendances de formation.policy dans
le fichier src/formation.policy/setup.py (option install_requires).
Lorsque vous êtes dans le dossier src, la commande svn stat vous renvoie les changements faits dans les externals,
ici les changements de formation.policy s’il y en a.
La commande svn up sera également faite dans les différents externals. La seule exception est la commade svn ci
exécutée à partir du dossier src ou plus en amont, les fichiers modifiés ou ajoutés dans les externals ne seront pas
commités.
Il faut vraiment être à l’intérieur de l’external, ici le dossier formation.policy pour que le commit des
changements soit réalisé.
Ceci dit, commitez le changement fait au fichier setup.py.
Editez buildout.cfg pour ajouter formation.policy :
[buildout]
#...
develop += src/formation.policy
[instance]
#...
eggs =
#...
formation.policy
zcml =
formation.policy
Exécutez bin/buildout.
L’ajout de formation.policy dans l’option zcml = ... génère un ZCML slug, fichier XML contenant
une seule ligne :
parts/instance/etc/package-includes/001-formation.policy-configure.zcml
<include package="formation.policy" file="configure.zcml" />
12.3. Création d’un policy package contenant la configuration du site Plone
133
Plone pour les intégrateurs, Version 1.0.0
En fait au démarrage de l’instance Zope, le fichier parts/instance/etc/site.zcml est lu, ce qui entraine
la lecture de tous les fichiers situés dans le dossier package-includes, ainsi que les fichiers meta.zcml,
configure.zcml et overrides.zcml des produits dans l’espace de nom Products.
La chaine de lecture est donc celle-ci :
– parts/instance/etc/site.zcml
– parts/instance/etc/package-includes/001-formation.policy-configure.zcml
– src/formation.policy/formation/policy/configure.zcml
Ces fichiers ZCML sont les fichiers de configuration utilisés par la ZCA (Zope Component Architecture) pour
enregistrer les composants au démarrage.
12.3.2 Installation de Products.Collage à l’installation de formation.policy
Vous allez maintenant
formation.policy.
dire
à
Plone
d’installer
Products.Collage
lorsque
vous
installez
Ouvrez le fichier src/formation.policy/formation/policy/configure.zcml, vous avez normalement ceci :
<configure
xmlns="http://namespaces.zope.org/zope"
xmlns:five="http://namespaces.zope.org/five"
xmlns:i18n="http://namespaces.zope.org/i18n"
xmlns:genericsetup="http://namespaces.zope.org/genericsetup"
i18n_domain="formation.policy">
<five:registerPackage package="." initialize=".initialize" />
<genericsetup:registerProfile
name="default"
title="formation.policy"
directory="profiles/default"
description="Installs the formation.policy package"
provides="Products.GenericSetup.interfaces.EXTENSION"
/>
<!-- -*- extra stuff goes here -*- -->
</configure>
La directive <five :registerPackage ..../> signale à Zope que c’est un module. Cette ligne est importante vu que nous ne sommes pas dans l’espace de nom Products.
La directive <genericsetup :registerProfile .../> permet d’enregistrer un nouveau profil d’extension (option provides) avec le nom default (option name). Les fichiers du profil se trouvent dans le
dossier profiles/default. (option directory).
Dans profiles/default, éditez le fichier metadata.xml comme ceci :
<?xml version="1.0"?>
<metadata>
<version>1000</version>
<dependencies>
<dependency>profile-Products.Collage:default</dependency>
</dependencies>
</metadata>
Le produit Products.Collage utilise bien un profil donc nous pouvons l’installer de cette manière.
Jetez un œil à la seule documentation qui existe sur le support des dépendances de produits dans metadata.xml.
Notez que la best practice est maintenant d’utiliser un entier pour la version du profile : 1000, 1001, 1002 et 2000,
2001 pour une branche parallèle. ArchGenXML ne respecte pas encore cette convention, il faut au moins deux
entiers séparés par un point, ex : 1.0. Ce sera sans doute corrigé dans une prochaine version.
134
Chapitre 12. Création d’un buildout Plone avec ZopeSkel
Plone pour les intégrateurs, Version 1.0.0
Dans la chaine profile-Products.Collage :default, nous avons le préfixe profile-, le package
au sens Python Products.Collage, le caractère : et le nom du profil à charger default. Ici default
est le name donné lors du genericsetup :registerProfile dans le fichier configure.zcml de
Products.Collage.
12.3.3 Déclaration de formation.policy comme plugin Plone
Plone 3.3 inclut un nouveau système de plugin. Un produit peut être déclaré plugin Plone.
Dans ce cas les fichiers meta.zcml, configure.zcml et overrides.zcml du produit seront lus au démarrage, comme pour les produits dans l’espace de nom Products.
Il n’est plus nécessaire d’ajouter le produit dans l’option zcml de la section [instance] dans
buildout.cfg.
Pour
cela
vérifiez
que
le
egg
src/formation.policy/setup.py :
est
déclaré
comme
plugin
Plone,
avec
dans
entry_points="""
[z3c.autoinclude.plugin]
target = plone
"""
Supprimez formation.policy de l’option zcml de la section [instance] dans buildout.cfg.
Et relancez bin/buildout qui va supprimer le fichier parts/instance/etc/package-includes/001-formation.p
La commande regénère également les metadonnées associées aux eggs en développement, concrètement il regénére le fichier src/formation.policy/formation.policy.egg-info/entry_points.txt qui
déclare le egg comme plugin Plone.
À quel moment est lu le fichier configure.zcml de formation.policy ? Il n’y a rien de magique, la
chaine de lecture est maintenant :
– parts/instance/etc/site.zcml
– lecture des fichiers configure.zcml de tous les produits dans l’espace de nom Products
– ~/.buildout/eggs/Plone-4.0.1-py2.6.egg/Products/CMFPlone/configure.zcml qui
contient les lignes :
<!-- include plone plugins with z3c.autoinclude -->
<includePlugins
zcml:condition="not-have disable-autoinclude"
package="plone"
file="configure.zcml"
/>
Note : includePlugins
includePlugins est une nouvelle directive fournie par z3c.autoinclude. Ici tous les eggs ayant un
entry point dans le groupe z3c.autoinclude.plugin sont recherchés. Nous avons dans cette directive
package="plone" donc seul les entry points avec target = plone sont gardés. Pour chaque eggs, le
fichier configure.zcml (option file de la directive) est lu.
– src/formation.policy/formation/policy/configure.zcml
Vous avez le même principe pour les fichiers meta.zcml et overrides.zcml, jetez un œil dans
Products/CMFPlone/meta.zcml et Products/CMFPlone/overrides.zcml.
12.3.4 Installation de Products.FCKeditor à l’installation de formation.policy
Pour dépendre de Products.FCKeditor, nous ne pouvons pas utiliser cette méthode car
Products.FCKeditor n’utilise pas de profil, mais l’ancien dossier Extensions pour être installé via le
tool portal_quickinstaller.
Il existe un produit pour installer des vieux produits à partir d’un profil : genericsetup.quickinstaller.
12.3. Création d’un policy package contenant la configuration du site Plone
135
Plone pour les intégrateurs, Version 1.0.0
Ce produit enregistre un nouvel importStep dans portal_setup qui regarde lors de l’installation d’un
produit s’il existe un fichier products.xml dans le dossier du profile.
Pour que cela marche, il faut que le fichier configure.zmcl de genericsetup.quickinstaller soit
lu d’une manière ou d’une autre au démarrage.
Ajoutez genericsetup.quickinstaller dans setup.py install_requires du policy package.
Il faut donc lire le fichier configure.zmcl du produit genericsetup.quickinstaller, vous pouvez
ajouter dans src/formation.policy/formation/policy/configure.zcml, cette directive :
<include package="genericsetup.quickinstaller" />
Ici l’option file n’est pas précisée, la valeur par défaut étant file="configure.zcml".
L’inconvénient de cette ligne est que vous avez l’information genericsetup.quickinstaller à deux
endroits, une première fois dans le fichier setup.py et une deuxième fois dans configure.zmcl.
Plone 3.3 inclut le package z3c.autoinclude qui permet de ne pas se répéter. En lieu et place de la ligne
ci-dessus, vous pouvez utiliser celle-ci :
<includeDependencies package="." />
Cette directive recupère la liste des dépendances du egg. Petit rappel, il le récupère à partir du fichier
src/formation.policy/formation.policy.egg-info/requires.txt qui lui a été généré à
partir des informations de setup.py.
Pour chaque dépendance dans l’ordre déclaré, elle va inclure dans l’ordre les fichiers meta.zcml,
configure.zmcl et overrides.zcml s’ils existent.
Pour finir, créez un fichier profiles/default/products.xml qui sera lu par l’importStep enregistré par
genericsetup.quickinstaller :
<?xml version="1.0"?>
<products>
<installs>
<product name="FCKeditor" />
</installs>
</products>
12.3.5 Configuration de FCKeditor pour tous les nouveaux utilisateurs
Vous allez configurer FCKeditor comme éditeur par défaut (seulement effectif pour les nouveaux utilisateurs).
Allez dans Configuration du site, ZMI, portal_setup, Snapshots. Créez un snapshot.
Retournez à la racine de la ZMI et cliquez sur portal_memberdata, cliquez sur l’onglet Properties.
Éditez la propriété wysiwyg_editor, mettez la valeur FCKeditor.
Retournez dans portal_setup, Snapshots. Recréez un snapshot. Cliquez maintenant sur l’onglet Comparison et
comparez vos deux snapshots. Vous voyez bien que la propriété wysiwyg_editor a été modifiée dans le fichier
memberdata_properties.xml.
Maintenant vous allez exporter cette configuration dans votre policy package. Cliquez sur portal_setup dans le
fil d’arianne, et cliquez sur l’onglet Export, sélectionnez le step MemberData properties, et cliquez sur Export
selected steps.
Téléchargez l’archive tar.gz proposée, extrayez son contenu dans un dossier temporaire et copiez le fichier
memberdata_properties.xml dans le dossier profiles/default de votre policy package.
Éditez le fichier pour ne laisser que la propriété qui vous intéresse. Vous devez donc avoir au final un fichier
profiles/default/memberdata_properties.xml avec ce contenu :
136
Chapitre 12. Création d’un buildout Plone avec ZopeSkel
Plone pour les intégrateurs, Version 1.0.0
<?xml version="1.0"?>
<object name="portal_memberdata" meta_type="PlonePAS MemberData Tool">
<property name="wysiwyg_editor" type="string">FCKeditor</property>
</object>
Vous pouvez exporter de cette façon presque la totalité des configurations des tools Plone.
Pour être sûr que l’import fonctionne bien, remettez TinyMCE dans wysiwyg_editor en ZMI.
Comme vous avez ajouté un fichier dans le profil, incrémentez la version dans metadata.xml, nous avons donc
la version 1001.
Maintenant si vous redémarrez l’instance et que vous allez dans Configuration du site, Modules, vous pouvez y
lire :
– formation.policy 1.0 Ce module a été mis à jour. L’ancienne version du profil est 1000. La nouvelle version du
profil est 1001. Il n’y a pas de procédure de mise à jour pour ce module. Merci de consulter la documentation
du module pour la mise à jour, ou contacter l’auteur du module.
Il faut en effet écrire un procédure de migration de la version 1000 vers la version 1001.
Note :
Il y a des bogues dans Products.GenericSetup 1.6.1 fourni avec Plone 4.0.1. Ouvrez
le fichier Products/GenericSetup/upgrade.py et remplacez ligne 220 if type(step) ==
UpgradeStep : par if isinstance(step, UpgradeEntity) :
et ligne 159, ajoutez un else :
def doStep(self, tool):
if self.import_profile is None:
profile_id = ’profile-%s’ % self.profile
else:
profile_id = self.import_profile
Ajoutez dans configure.zcml :
<genericsetup:upgradeDepends
title="formation.policy 1000 to 1001"
description="Configure FCKeditor as default wysiwyg editor"
profile="formation.policy:default"
source="1000"
destination="1001"
import_steps="memberdata-properties"
/>
Note : Liste des import steps :
typeinfo, tinymce_settings, atcttool, actions, skins, factorytool, placeful_workflow, componentregistry, controlpanel, placeful_marker, jsregistry, action-icons, cmfeditions_various, reference_catalog, viewlets, content, propertiestool, various, portlets, content_type_registry, plone-final, kssregistry, ploneopenid-various, update-workflowrolemap, sharing, uid_catalog, workflow, cssregistry, contentrules, cookie_authentication, catalog, difftool, plonecontent, toolset, properties, jquerytools-various, tinymce_various, browserlayer, plone-difftool, memberdataproperties, kss_mimetype, caching_policy_mgr, archetypetool, mailhost, rolemap, various-calendar, qiproducts,
archetypes-various
Si vous redémarrez l’instance, vous aurez :
– formation.policy 1.0 Ce module a été mis à jour. L’ancienne version du profil est 1000. La nouvelle version du
profil est 1001. Mettre à jour : formation.policy
Vous n’avez plus qu’à cliquer sur le bouton pour mettre à jour votre module. L’option wysiwyg_editor devrait
maintenant être FCKeditor.
Note : Commitez vos changements :
$ svn add formation/policy/profiles/default/metadata.xml \
formation/policy/profiles/default/products.xml
$ svn ci -m"Added configuration"
12.3. Création d’un policy package contenant la configuration du site Plone
137
Plone pour les intégrateurs, Version 1.0.0
En exercice : installez plone.app.discussion, le nouveau système de commentaire qui sera intégré dans
Plone 4.1.
Ajoutez plone.app.discussion dans setup.py. Incrémentez version dans metadata.xml, ajouter la dépendance profile-plone.app.discussion :default. Gelez la version 3.6.4 de zope.shema.
<?xml version="1.0"?>
<metadata>
<version>1002</version>
<dependencies>
<dependency>profile-Products.Collage:default</dependency>
<dependency>profile-plone.app.discussion:default</dependency>
</dependencies>
</metadata>
<genericsetup:upgradeDepends
title="formation.policy 1001 to 1002"
description="Installs plone.app.discussion"
profile="formation.policy:default"
import_profile="profile-plone.app.discussion:default"
run_deps="True"
source="1001"
destination="1002"
/>
12.4 À propos des versions
Le panneau de configuration Produits d’extension accessible via Configuration du site est une interface à portal_quickinstaller et portal_setup.
Elle permet d’installer les produits n’ayant pas de profile avec portal_quickinstaller et les produits avec profile
avec portal_setup.
Les versions affichées sont celles des eggs. La version est récupérée via le module pkg_resources fourni par
setuptools comme vu précédemment.
La version du egg et du profil peuvent être différentes. Il est même conseillé dès le départ d’utiliser des versions
différentes pour la version du produit/egg, et la version du profil.
La version du egg est une version de la forme 1.0.0, 1.0.1, 1.1.0 etc. Si vous modifiez du code Python ou des
templates, incrémentez cette version.
La version du profile est un simple entier qui est incrémenté à chaque fois qu’un fichier est modifié ou ajouté dans
le dossier du profile. Vous incrémenterez généralement aussi la version du egg.
12.5 Releaser le policy package
Maintenant que vous avez un policy package qui fait quelque chose, il est peut-être temps de réaliser une release
pour pouvoir l’utiliser en production. En effet il n’est pas conseillé d’utiliser des produits en mode développement
en production.
La première chose à faire et d’éditer le changelog dans le fichier docs/HISTORY.txt.
Ce fichier texte est au format reST (reStructuredText). Il faut respecter certaines conventions d’écriture pour que
ce fichier puisse être généré ensuite en HTML sur Pypi.
– le soulignage d’un titre doit aller exactement jusqu’au bout du titre.
– les listes doivent avoir une ligne vide au début et à la fin
138
Chapitre 12. Création d’un buildout Plone avec ZopeSkel
Plone pour les intégrateurs, Version 1.0.0
Pour cette première release, vous allez seulement spécifier la date de la release. Remplacez juste unreleased par
2009-06-11. Remplacez également la puce de la liste, l’étoile par un tiret qui est la convention dans les produits
Plone.
Votre fichier doit ressembler à ceci :
Changelog
=========
1.0 (2009-06-11)
---------------- Initial release
La version dans setup.py doit également être 1.0.
Commitez :
$ svn ci -m "Prepare release"
Maintenant vous allez faire un tag, c’est-à-dire une copie d’une branche qui sera gelée, faire un checkout de ce tag
et pousser la release :
$
$
$
$
$
svn cp http://devagile/Formation/packages/formation.policy/trunk http://devagile/Formation/packa
cd /tmp
svn co http://devagile/Formation/packages/formation.policy/tags/1.0
cd 1.0/
python setup.py egg_info -RDb "" mregister sdist --formats=zip mupload -r mycompany
Il y a aussi une autre manière de faire, au lieu de préciser egg_info -RDb "", vous pouvez supprimer le
fichier setup.cfg, commiter et faire la release sans préciser egg_info -RDb "".
Retournez ensuite dans le trunk (dossier src/formation.policy/), incrémentez la version dans
setup.py, donc ici 1.1. Et éditez le fichier HISTORY.txt comme ceci :
Changelog
=========
1.1 (unreleased)
---------------1.0 (2009-06-11)
---------------- Initial release
Et commitez :
$ svn ci -m "Update version after release"
Pour plus d’informations sur la manière de faire une release, voyez les liens suivants :
– http ://grok.zope.org/documentation/how-to/releasing-software
– http ://plone.org/documentation/tutorial/how-to-upload-your-package-to-plone.org
Note : Toutes ces étapes peuvent être faites avec une seule commande fullrelease. Pour cela installez le package
zest.releaser dans votre environnement :
$ workon myenv
(myenv)$ easy_install zest.releaser
Démarrez votre instance Plone où vous avez installé votre pypi. Pour releaser votre package :
(myenv)$ cd src/formation.policy
(myenv)$ fullrelease
12.5. Releaser le policy package
139
Plone pour les intégrateurs, Version 1.0.0
La commande fullrelease exécute séquentiellement les commandes prerelease, release et postrelease.
Vous allez dorénavant utiliser cette version releasée plutôt que le egg en développement.
Supprimez formation.policy de l’option develop de la section [buildout] dans buildout.cfg.
Ajoutez aussi le lien vers le Pypi dans find-links :
[buildout]
find-links +=
# ...
http://devagile:8080/site/products/simple
Précisez la version formation.policy = 1.0 dans versions.cfg.
L’external ne sera plus utilisé dans la suite, donc supprimez le également :
$ svn rm src/EXTERNALS.txt
$ svn propdel svn:externals src/
$ svn ci -m "Removed external"
12.6 Repasser au développement
Maintenant vous voulez repasser le egg formation.policy en mode développement pour travailler dessus. Il
faut :
– supprimer la version dans versions.cfg
– ajouter le egg dans l’option develop de buildout.cfg
– reconfigurer l’external pour récupérer le egg dans le dossier src
Passer du mode développement au mode production et vice-versa génère beaucoup de bruit dans les logs svn, mais
surtout il faut sans cesse répéter les mêmes actions.
Nous allons utiliser dans la suite une extension buildout nommée mr.developer qui s’occupe de réaliser les 3
étapes décrites ci-dessus en une commande.
12.7 Utilisation de mr.developer pour gérer les composants en développement
L’extension pour zc.buildout mr.developer permet de gérer les composants en développement, et de commuter
facilement d’un composant en développement à sa version “releasée” et inversement.
Transformez le fichier buildout.cfg :
extends =
# ...
sources.cfg
extensions =
# ...
mr.developer
Créez le fichier sources.cfg avec ce contenu :
[buildout]
always-checkout = force
auto-checkout =
formation.policy
[sources]
formation.policy = svn http://devagile/Formation/packages/formation.policy/trunk
140
Chapitre 12. Création d’un buildout Plone avec ZopeSkel
Plone pour les intégrateurs, Version 1.0.0
Exécutez bin/buildout et mr.developer va s’occuper de faire un checkout de formation.policy dans le
dossier src.
L’extension s’occupe aussi de passer en mode développement formation.policy et de supprimer
formation.policy de versions.cfg pour que ce soit bien la version en développement qui soit utilisée. Cela est fait de manière interne, les fichiers ne sont pas touchés.
mr.developer génère le script bin/develop qui est un script à tout faire.
Exécutez bin/develop help pour obtenir la liste des commandes, qui ressemblent beaucoup à subversion.
bin/develop stat vous liste les checkouts du dossier src, vous dit s’ils sont actifs ou non (c’est-à-dire en mode
développement ou non) et s’ils sont dans l’option auto-checkout ou non. Exécutez bin/develop help stat pour
obtenir la légende.
bin/develop co plonetheme.formation fait un checkout dans le dossier src, et active le egg (le met en mode
développement).
bin/develop activate plonetheme.formation suivi de bin/buildout permet de passer le egg en mode développement.
bin/develop deactivate plonetheme.formation suivi de bin/buildout permet de désactiver le mode développement et d’utiliser la version spécifiée dans versions.cfg.
bin/develop up -vf permet de mettre à jour tous les checkouts. L’option -v permet d’afficher les messages de
subversion. L’option -f permet de forcer un svn up si le checkout est dans un état pas clean.
L’idée est d’ajouter dans auto-checkout les eggs qui ont été modifiés après leur dernière release. Comme ceci
lorsqu’il est temps de livrer votre travail en production, vous savez exactement quels sont les eggs dont vous devez
faire une release.
12.8 Fabric
Créez un environnement isolé Python >= 2.5 avec Fabric d’installé :
$ mkvirtualenv -p /usr/bin/python2.6 --no-site-packages fab
(fab)$ easy_install Fabric
Création d’un script Fabric pour la maintenance de l’instance Plone à distance. Créez un fichier fabfile.py à
la racine de votre buildout :
from fabric.api import run, sudo, env, hosts
env.user = "anthony"
env.hosts = [’devagile’]
def update():
"""Update the checkout of the buildout
"""
run("cd /home/anthony/workspace/plone4; svn up")
def restart():
"""Restart the instance
"""
run("/home/anthony/workspace/plone4/bin/instance restart")
def stop():
"""Stop the instance
"""
run("/home/anthony/workspace/plone4/bin/instance stop")
def start():
"""Start the instance
12.8. Fabric
141
Plone pour les intégrateurs, Version 1.0.0
"""
run("/home/anthony/workspace/plone4/bin/instance stop")
def buildout():
"""Run bin/buildout
"""
run("cd /home/anthony/workspace/plone4; bin/buildout")
def up_and_restart():
"""Update the checkout and restart the instance
"""
update()
restart()
def full_up_and_restart():
"""Do the actions stop, update, buildout, start
"""
stop()
update()
buildout()
start()
Pour afficher la liste des commandes disponibles :
$ fab --list
Available commands:
buildout
full_up_and_restart
restart
start
stop
up_and_restart
update
Run bin/buildout
Do the actions stop, update, buildout, start
Restart the instance
Start the instance
Stop the instance
Update the checkout and restart the instance
Update the checkout of the buildout
Pour redémarrer l’instance :
$ fab restart
Pour préciser un autre host qui va donc écraser le host configuré globalement dans le fichier :
$ fab stop:host=ailleurs
Vous pouvez aussi créer des commandes avec des paramètres, exécutez fab -h pour consulter la liste des options.
Pour plus de détails, consulter la documentation de Fabric
12.9 Ressources
– http ://plone.org/documentation/tutorial/buildout
– http ://www.sixfeetup.com/swag/buildout-quick-reference-card
142
Chapitre 12. Création d’un buildout Plone avec ZopeSkel
CHAPITRE 13
Déploiement et backup
Author Vincent Fretin
Contributors Thomas Desvenain
Version 1.0.0
Révision https ://svn.plone.org/svn/collective/collective.trainingmanual/trunk/fr/integrateur/source/presentation_plone.txt
Copyright (C) 2010 Vincent Fretin <vincentfretin AT ecreall.com>.
Chacun est autorisé à copier, distribuer et/ou modifier ce document suivant les termes de la licence
Paternité-Pas d’Utilisation Commerciale-Partage des Conditions Initiales à l’Identique 2.0 France accessible à
http ://creativecommons.org/licenses/by-nc-sa/2.0/fr
Le code source présent dans ce document est soumis aux conditions de la « Zope Public License », Version 2.1
(ZPL).
THE SOURCE CODE IN THIS DOCUMENT AND THE DOCUMENT ITSELF IS PROVIDED “AS IS” AND
ANY AND ALL EXPRESS OR IMPLIED WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT,
AND FITNESS FOR A PARTICULAR PURPOSE.
–
–
–
–
–
–
–
–
–
–
–
–
Définition
Savoir
Profil de déploiement
Supervisor
Support des backups
Cron job pour zeopack et backup
Configuration d’Apache
– Activation de la compression
Configuration des DNS
Installation et configuration de CacheFu (< Plone 4)
– Installation
– Configuration
Installation et configuration de plone.app.caching (>= Plone 4)
– Installation
– Le panneau de configuration de la gestion de cache
– Configuration
– Tester
Ressources
Exercice
143
Plone pour les intégrateurs, Version 1.0.0
13.1 Définition
Le déploiement d’un site Plone requiert des options particulières. Par exemple, nous voulons être sûr qu’une
configuration d’un buildout produit la même chose aujourd’hui ou dans un an.
Vous avez également des environnements différents, donc vous aurez un fichier de configuration par environnement (développement, intégration, production, ...). Chaque fichier principal development.cfg,
deployment.cfg, deployment-backup.cfg étant une extension d’une configuration de base
buildout.cfg intégrant tous les modules applicatifs.
13.2 Savoir
–
–
–
–
–
–
–
Profil buildout de déploiement
Mettre en place un backup de la ZODB
Apache
Varnish
HAproxy
CacheFu / plone.app.caching
Supervisor
13.3 Profil de déploiement
Rappel
Vous pouvez réviser vos connaissances sur buildout en relisant le chapitre Création d’un buildout Plone avec
ZopeSkel.
Vous pouvez récupérer l’exemple complet de buildout sur le collective :
$ svn co https://svn.plone.org/svn/collective/collective.trainingmanual/trunk/fr/examples/buildout
Le buildout.cfg du chapitre précédent est légèrement modifié :
buildout.cfg
[buildout]
extends =
http://dist.plone.org/release/4.0.1/versions.cfg
http://good-py.appspot.com/release/plone.app.caching/1.0b1?five.grok=1.1.2
sources.cfg
versions.cfg
parts +=
instance1
zopepy
repozo
backup
extensions =
mr.developer
buildout.dumppickedversions
always-checkout = force
versions = versions
#allow-hosts =
#
pypi.python.org
#
dist.plone.org
#
dist.plone.org:5021
#
labix.org
144
Chapitre 13. Déploiement et backup
Plone pour les intégrateurs, Version 1.0.0
# dist.plone.org: PIL
# labix.org: python-dateutil
find-links =
#
http://devagile:8080/site/products/simple
http://dist.plone.org/release/4.0.1
#
http://dist.plone.org/thirdparty
eggs +=
PIL
[instance1]
recipe = plone.recipe.zope2instance
user = admin:admin
http-address = 8280
eggs =
#
formation.policy
${buildout:eggs}
environment-vars =
PYTHON_EGG_CACHE ${buildout:directory}/tmp
zope_i18n_compile_mo_files true
zcml =
event-log-custom =
<logfile>
level info
path ${buildout:directory}/var/log/${:_buildout_section_name_}.log
max-size 1MB
old-files 720
</logfile>
<logfile>
level error
path ${buildout:directory}/var/log/error.log
max-size 1MB
old-files 720
</logfile>
access-log-custom =
<logfile>
path ${buildout:directory}/var/log/${:_buildout_section_name_}-Z2.log
max-size 1MB
old-files 720
</logfile>
[zopepy]
recipe = zc.recipe.egg
eggs = ${instance1:eggs}
interpreter = zopepy
scripts = zopepy
[repozo]
recipe = zc.recipe.egg
eggs = ZODB3 [test]
#scripts = repozo
[backup]
recipe = collective.recipe.backup
keep = 7
full = true
gzip = true
Créez un fichier deployment.cfg :
deployment.cfg
13.3. Profil de déploiement
145
Plone pour les intégrateurs, Version 1.0.0
[buildout]
extends-cache = extends-cache
extends =
buildout.cfg
parts +=
zeoserver
instance1
instance2
instance3
instance4
varnish-build
varnish-conf
varnish
haproxy
haproxy-conf
supervisor
munin1
munin2
munin3
munin4
eggs +=
plone.app.caching
[hosts]
zeoserver
instance1
instance2
instance3
instance4
varnish
haproxy
supervisor
=
=
=
=
=
=
=
=
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
127.0.0.1
[ports]
zeoserver
instance1
instance2
instance3
instance4
varnish
haproxy
supervisor
=
=
=
=
=
=
=
=
8100
9880
9881
9882
9883
8000
5501
9001
[users]
zope
varnish
haproxy
= zope
= zope
= zope
[zeoserver]
recipe = plone.recipe.zeoserver
zeo-address = ${hosts:zeoserver}:${ports:zeoserver}
[instance1]
shared-blob = on
zeo-client = true
zeo-address = ${zeoserver:zeo-address}
effective-user = ${users:zope}
http-address = ${hosts:instance1}:${ports:instance1}
[instance2]
<= instance1
http-address = ${hosts:instance2}:${ports:instance2}
146
Chapitre 13. Déploiement et backup
Plone pour les intégrateurs, Version 1.0.0
ftp-address = 9821
[instance3]
<= instance1
http-address = ${hosts:instance3}:${ports:instance3}
[instance4]
<= instance1
http-address = ${hosts:instance4}:${ports:instance4}
[supervisor]
recipe = collective.recipe.supervisor
port = ${ports:supervisor}
user = admin
password = admin
plugins = superlance
supervisord-conf = ${buildout:directory}/etc/supervisord.conf
serverurl = http://${hosts:supervisor}:${ports:supervisor}
programs =
10 zeoserver ${zeoserver:location}/bin/runzeo ${zeoserver:location} true ${users:zope}
20 instance1 ${buildout:bin-directory}/instance1 [console] ${instance1:location} true
30 instance2 ${buildout:bin-directory}/instance2 [console] ${instance2:location} true
40 instance3 ${buildout:bin-directory}/instance3 [console] ${instance3:location} true
50 instance4 ${buildout:bin-directory}/instance4 [console] ${instance4:location} true
60 haproxy ${buildout:bin-directory}/haproxy [-f ${buildout:directory}/etc/haproxy.conf -db] t
70 varnish (autorestart=true) ${buildout:bin-directory}/varnish ${varnish:location} true
eventlisteners =
#
memmon TICK_60 ${buildout:bin-directory}/memmon [-p instance1=600MB -p instance2=600MB -p ins
#
crashmail PROCESS_STATE ${buildout:bin-directory}/crashmail [-m [email protected]]
[varnish-build]
recipe = zc.recipe.cmmi
url = ${varnish:download-url}
[varnish-conf]
recipe = collective.recipe.template
input = ${buildout:directory}/templates/varnish.vcl.in
output = ${buildout:directory}/etc/varnish.vcl
[varnish]
recipe = plone.recipe.varnish
daemon = ${buildout:parts-directory}/varnish-build/sbin/varnishd
bind = ${hosts:varnish}:${ports:varnish}
#backends = ${haproxy-conf:bind}
config = ${varnish-conf:output}
cache-size = 256M
user = ${users:varnish}
mode = foreground
[haproxy]
recipe = plone.recipe.haproxy
url = ${versions:haproxy-url}
cpu = i686
target = linux26
pcre = 1
[haproxy-conf]
recipe = collective.recipe.template
input = ${buildout:directory}/templates/haproxy.conf.in
output = ${buildout:directory}/etc/haproxy.conf
maxconn = 32000
ulimit-n = 65536
user = ${users:haproxy}
13.3. Profil de déploiement
147
Plone pour les intégrateurs, Version 1.0.0
group = ${users:haproxy}
bind = ${hosts:haproxy}:${ports:haproxy}
[munin1]
recipe = zc.recipe.egg
eggs = munin.zope
scripts = munin=munin1
arguments = ip_address=’${hosts:instance1}’, http_address=’${ports:instance1}’, user="${instance1:
[munin2]
recipe = zc.recipe.egg
eggs = munin.zope
scripts = munin=munin2
arguments = ip_address=’${hosts:instance2}’, http_address=’${ports:instance2}’, user="${instance2:
[munin3]
recipe = zc.recipe.egg
eggs = munin.zope
scripts = munin=munin3
arguments = ip_address=’${hosts:instance3}’, http_address=’${ports:instance3}’, user="${instance3:
[munin4]
recipe = zc.recipe.egg
eggs = munin.zope
scripts = munin=munin4
arguments = ip_address=’${hosts:instance4}’, http_address=’${ports:instance4}’, user="${instance4:
Vous allez créer un utilisateur zope qui servira pour lancer le proxy cache varnish, le load balancer HAproxy et
les instances zope.
$ sudo adduser zope
Note : Si vous avez installé un Plone en root avec l’unified installer, vous pouvez utiliser le compte plone au lieu de
créer un compte zope. Pour cela remplacer zope par plone dans la section [users] du fichier deployment.cfg.
Note : Il faut que les fichiers appartiennent à l’utilisation zope ou plone où vous aurez des problèmes pour
démarrer le zeoserver par exemple. Donc vérifiez que les fichiers ont bien le bon propriétaire :
$ sudo chown -R zope votre_buildout
Relancez le buildout avec bin/buildout -c deployment.cfg.
13.4 Supervisor
Le buildout génère le fichier etc/supervisord.conf.
Tous les processus sont gérés par supervisor.
Pour lancer supervisor, lancez le daemon en tant que super utilisateur qui lancera tous les processus ayant autostart=true (par defaut) :
$ sudo bin/supervisord
(varnish et haproxy ont besoin d’être démarrés en root pour activer certaines options. Les processus sont ensuite
forkés pour utiliser l’utilisateur zope)
Vous pouvez voir l’état des processus avec :
$ bin/supervisorctl status
Pour redémarrer un processus par exemple instance1 :
148
Chapitre 13. Déploiement et backup
Plone pour les intégrateurs, Version 1.0.0
$ bin/supervisorctl restart instance1
Pour stopper : stop, pour démarrer : start.
Pour tout redémarrer :
$ bin/supervisorctl restart all
Pour arrêter supervisor et donc tous les processus :
$ bin/supervisorctl shutdown
13.5 Support des backups
Pour les backups, c’est la section backup.
[backup]
recipe = collective.recipe.backup
keep = 7
full = true
gzip = true
Vous avez par défaut les options suivantes :
location = ${buildout-directory}/var/backups
snapshotlocation = ${buildout-directory}/var/snapshotbackups
Plus d’informations sur les options de la recipe
Pour exécuter la sauvegarde toutes les nuits, vous pouvez ajouter un cron job (crontab -e), ici à 3h du matin :
00 3 * * *
/home/zope/MyProject/bin/backup -q
Vous allez voir dans la suite une configuration de buildout qui s’occupe de créer le cron job à votre place.
Pour faire une restauration :
$ bin/restore
Si vous voulez faire un backup de la production pour travailler ensuite en local, utilisez plutôt la commande :
$ bin/snapshotbackup
qui créera une sauvegarde dans le dossier var/snapshotbackups/, utile pour ne pas perturber les sauvegardes normales qui se font la nuit. Vous récupérez ensuite la sauvegarde (les fichiers .fsz et .dat)
via scp et vous placez la sauvegarde dans votre dossier var/snapshotbackups/ en local et exécutez
bin/snapshotrestore en local.
13.6 Cron job pour zeopack et backup
Voici un exemple de configuration qui étend deployment.cfg pour réaliser un pack de la database avec la
commande bin/zeopack et faire un backup avec la commande bin/backup vue précédemment.
Il synchronise également les dossiers backup/ et log/ sur un autre serveur.
Tout cela est réalisé par un job cron à 3h du matin.
deployment-backup.cfg
13.5. Support des backups
149
Plone pour les intégrateurs, Version 1.0.0
[buildout]
extends-cache = extends-cache
extends = deployment.cfg
parts +=
backup-template
backup-schedule
[backup-template]
recipe = collective.recipe.template
inline =
#!/bin/bash
${buildout:bin-directory}/zeopack
${buildout:bin-directory}/backup -q
blob=$(basename ‘ls ${backup:location}|tail -n1‘ .fsz)
cd ${buildout:directory}
tar zcf ${backup:location}/$blob.tar.gz var/blobstorage
toremove=‘ls ${backup:location}/*.tar.gz|sort -r|tail -n+8‘
if [ ! -z "$toremove"]; then rm $toremove; fi
#
rsync -a --delete ${backup:location}/ [email protected]:/home/sav/Plone/backups/
#
rsync -a --delete ${buildout:directory}/var/log/ [email protected]:/home/sav/Plone/log
output = ${buildout:bin-directory}/backup.sh
mode = 755
[backup-schedule]
recipe = z3c.recipe.usercrontab
times = 0 4 * * *
command = ${backup-template:output}
Dans cet exemple, la synchronisation se fait sur le serveur de secours/backup serveur1.example.com avec le login
save. Il vous faut préalablement partager une clé publique entre ces deux serveurs pour que la commande rsync
ne demande aucun mot de passe.
Pour utiliser cette configuration, exécutez bin/buildout -c deployment-backup.cfg. Le cron job sera automatiquement ajouté dans le crontab de l’utilisateur.
13.7 Configuration d’Apache
Création d’un certificat autosigné :
$ sudo mkdir -p /etc/apache2/ssl/
$ sudo make-ssl-cert /usr/share/ssl-cert/ssleay.cnf \
/etc/apache2/ssl/server.crt
/etc/apache2/sites-available/devagile :
NameVirtualHost 127.0.0.1
<VirtualHost 127.0.0.1:80>
ServerName devagile
ServerAdmin [email protected]
ErrorLog /var/log/apache2/devagile_error.log
TransferLog /var/log/apache2/devagile_access.log
LogLevel warn
RewriteEngine On
RewriteRule ^/(.*) https://ssl.devagile/$1 [NC,R=301,L]
</VirtualHost>
/etc/apache2/sites-available/ssl.devagile :
150
Chapitre 13. Déploiement et backup
Plone pour les intégrateurs, Version 1.0.0
NameVirtualHost 127.0.0.1:443
<VirtualHost 127.0.0.1:443>
ServerName ssl.devagile
ServerAdmin [email protected]
ErrorLog /var/log/apache2/devagile_error.log
TransferLog /var/log/apache2/devagile_access.log
LogLevel warn
SSLEngine On
SSLCertificateFile /etc/apache2/ssl/server.crt
#SSLCertificateKeyFile /etc/apache2/ssl/server.key
RewriteEngine On
RewriteRule ^/(.*) http://localhost:8000/VirtualHostBase/https/%{SERVER_NAME}:443/Plone/Virtua
<IfModule mod_proxy.c>
<Proxy proxy:http://localhost:8000>
Order deny,allow
Allow from localhost
</Proxy>
</IfModule>
</VirtualHost>
Activez les sites :
$ a2ensite devagile
$ a2ensite ssl.kb
Activez les modules :
$
$
$
$
$
a2enmod
a2enmod
a2enmod
a2enmod
a2enmod
ssl
dav
proxy
proxy_http
rewrite
13.7.1 Activation de la compression
Activez le module deflate :
$ a2enmod deflate
et éditez le fichier de configuration /etc/apache2/mods-enabled/deflate.conf (pas besoin avec
Ubuntu 10.04) :
<IfModule mod_deflate.c>
# these are known to be safe with MSIE 6
AddOutputFilterByType DEFLATE text/html text/plain text/xml
# everything else may
AddOutputFilterByType
AddOutputFilterByType
AddOutputFilterByType
</IfModule>
cause problems with MSIE 6
DEFLATE text/css
DEFLATE application/x-javascript application/javascript application/
DEFLATE application/rss+xml
Redémarrez Apache :
$ /etc/init.d/apache2 restart
13.7. Configuration d’Apache
151
Plone pour les intégrateurs, Version 1.0.0
13.8 Configuration des DNS
Pour configurer vos DNS ou pour tester en local, éditez /etc/hosts :
127.0.0.1 devagile ssl.devagile
Redémarrez Firefox pour qu’il relise le fichier.
Vous accéderez à votre site à partir de maintenant avec l’adresse http ://devagile.
13.9 Installation et configuration de CacheFu (< Plone 4)
CacheFu est un module pour gérer les règles de cache HTTP pour Plone < 4.
13.9.1 Installation
Pour installer CacheFu il suffit d’ajouter Products.CacheSetup soit dans la liste des eggs de votre buildout,
soit en tant que dépendance à l’un de vos projets dans le setup.py. Vous devez ensuite l’installer par la suite
comme un module supplémentaire dans le panneau de configuration de Plone via l’utilitaire Ajout/Suppression de
produits.
13.9.2 Configuration
Allez avec le navigateur en tant qu’administrateur dans Configuration du site -> Cache Configuration Tool et
configurez de la manière suivante :
– Cocher Enable CacheFu
– Active Cache Policy : With Caching Proxy
– Proxy Cache Purge Configuration : Purge with VHM URLS
– Site Domains : https ://ssl.devagile :443
– Proxy Cache Domains : http ://127.0.0.1 :8000
– Compression : Never
13.10 Installation et configuration de plone.app.caching (>= Plone
4)
plone.app.caching propose comme CacheFu une interface graphique pour gérer les règles de cache HTTP
pour Plone 4. Il est construit sur z3c.caching, plone.caching et plone.cachepurging.
13.10.1 Installation
Pour installer plone.app.caching il suffit de l’ajouter soit dans la liste des eggs de votre buildout, soit en tant que
dépendance à l’un de vos projets dans le setup.py. Vous devez ensuite l’installer comme un module supplémentaire dans le panneau de configuration de Plone via l’utilitaire d’ajout de modules. Comme ce module dépend
d’un certain nombre de modules qui ne sont pas fournis par Plone, il est plus sûr de geler les versions dans votre
buildout comme suit :
extends =
# ...
http://good-py.appspot.com/release/plone.app.caching/1.0b1
152
Chapitre 13. Déploiement et backup
Plone pour les intégrateurs, Version 1.0.0
Vous pouvez avoir une vue des versions disponibles ici : http ://good-py.appspot.com/release/plone.app.caching
Note : http ://good-py.appspot.com est une application Google App Engine créée par Martin Aspeli pour gérer un
ensemble de KGS (Know Good Set), avec des contraintes de versions compatibles et incompatibles. Par exemple
pour récupérer le KGS de plone.app.caching et de five.grok, vous pouvez utiliser l’url suivante : http ://goodpy.appspot.com/release/plone.app.caching/1.0b1 ?five.grok=1.1.2 Pour récupérer un KGS de five.grok compatible
avec Plone 3.3 qui utilise Zope 2.10.x : http ://good-py.appspot.com/release/five.grok/1.1.2 ?zope=2.10.x
13.10.2 Le panneau de configuration de la gestion de cache
Une fois installé vous allez trouver au niveau de la configuration de votre site un lien pour configurer les règles de
cache de votre site.
Cette interface graphique est constituée de trois onglets :
1. Changer la configuration (Change settings) : pour gérer le comportement du cache HTTP
2. Importer une configuration (Import settings) : vous permet d’importer des politiques de cache prédéfinies
3. RAM cache : fournit des informations statistiques sur le cache en RAM et son éventuelle purge.
13.10.3 Configuration
Dans notre exemple, nous avons un cache proxy varnish derrière Apache. Pour configurer cette chaine, faire ce
qui suit :
– Cliquer sur Import settings, sélectionner With caching proxy, cliquer sur Import
– Retourner dans Change settings, dans Global settings, cocher Enable caching
– Dans l’onglet Caching proxies, cocher Enable purging
– Ajouter http ://127.0.0.1 :8000 dans les Caching proxies.
– Cocher Virtual host rewriting takes place front of the caching proxy car les adresses sont réécritent par Apache
avec le RewriteRule.
– Dans Externally facing domains, mettre https ://ssl.devagile :443
– Cliquer sur Save
Le mieux après est d’exporter cette configuration dans formation.policy. Pour cela aller dans portal_setup, export,
registry. Ajouter le fichier registry.xml dans votre dossier profiles/default/. Eventuellement nettoyer ce
fichier, seules les clés commencant par plone.app.caching nous intéressent.
Pour aller plus loin : http ://dev.plone.org/plone/browser/plone.app.caching/trunk/README.txt
13.10.4 Tester
Vous pouvez tester que votre configuration fonctionne bien en inspectant les requêtes HTTP avec l’extension
Firebug de Firefox par exemple.
13.10. Installation et configuration de plone.app.caching (>= Plone 4)
153
Plone pour les intégrateurs, Version 1.0.0
13.11 Ressources
– Varnish Guru Meditation on timeout
– Plone Scaling and Performance par Elizabeth Leddy
Apache et Zope, VirtualHostMonster :
– http ://plone.org/documentation/tutorial/plone-apache/vhm/
– http ://plone.org/documentation/how-to/plone-with-apache
– http ://www.zope.org/Documentation/Books/ZopeBook/2_6Edition/VirtualHosting.stx
– http ://wiki.zope.org/zope2/ZopeAndApache
– http ://doc.ubuntu-fr.org/tutoriel/securiser_apache2_avec_ssl
Erreurs PosKey dans vos ZODB storages :
– Checking your ZODB storages for PosKey errors
13.12 Exercice
Geler toutes les versions des eggs utilisés dans le buildout.
Ajout de la recipe collective.recipe.backup dans le buildout pour réaliser un backup régulier de la base de données.
154
Chapitre 13. Déploiement et backup
CHAPITRE 14
Zope External Editor
–
–
–
–
Activation du lien “Modifier avec une application externe”
Installation du client External Editor sous Ubuntu
Installation du client External Editor sous Windows
Problèmes de cache avec l’External Editor
14.1 Activation du lien “Modifier avec une application externe”
L’option Activer la fonctionalité d’éditeur externe doit être coché depuis Configuration du site, puis Edition. Cette
fonctionalité requiert l’installation d’une application sur le poste des utilisateurs. Ils devront aussi l’activer dans
leurs préférences personnelles.
Pour forcer l’utilisation de l’éditeur externe par tous vos utilisateurs, allez dans la Configuration du site, ZMI,
portal_memberdata, cliquez sur l’onglet Properties, et cochez l’option ext_editor.
Cela activera le lien Modifier avec une application externe à côté des liens Envoyer cette page et Imprimer sur les
documents.
Note :
Il y a un bogue dans Plone 3.3.2 qui empêche ce lien de fonctionner. Éditez
~/.buildout/eggs/Plone-3.3.2-py2.4.egg/Products/CMFPlone/skins/plone_scripts/external_ed
et remplacez ’%s/externalEdit_/%s.zem’ par ’%s/externalEdit_/%s’.
14.2 Installation du client External Editor sous Ubuntu
Le système de package d’Ubuntu propose une ancienne version de zopedit. Nous allons quand même l’installer
car il associe le type mime application/x-zope-edit à /usr/bin/zopeedit Nous allons ensuite remplacer le script par
une nouvelle version.
Installez donc zopeedit via le système de packages :
$ sudo apt-get install zopeedit
Ensuite récupérer la dernière version du script Python zopeedit.py sur http ://plone.org/products/zopeexternaleditor-client
et remplacez /usr/bin/zopeedit par celui-ci :
$ sudo cp zopeedit.py /usr/bin/zopeedit
155
Plone pour les intégrateurs, Version 1.0.0
Supprimez éventuellement l’ancien fichier ~/.zope-external-edit et exécutez zopedit dans un terminal
pour recréer un fichier de configuration.
Depuis la version 0.9.11pre1, le support du versionnement des documents est supporté, mais désactivé par défaut.
Pour activer le versionnement des documents, éditez le fichier ~/.zope-external-edit et remplacez :
# Create a new version when the file is closed ?
# version_control = 0
par :
# Create a new version when the file is closed ?
version_control = 1
14.3 Installation du client External Editor sous Windows
Téléchargez la dernière version de l’installateur à partir de http ://plone.org/products/zope-externaleditor-client et
exécutez le.
14.4 Problèmes de cache avec l’External Editor
Le problème suivant peut survenir : l’utilisateur clique sur Modifier avec une application externe, il l’édite, sauvegarde et lorsqu’il reclique sur le lien, il récupère l’ancienne version. Il peut y avoir deux raisons à cela. Le
navigateur n’a pas redemandé le fichier, il l’a pris de son cache. Ou bien le proxy cache a retourné une version
cachée du fichier.
Il semble que l’on ne puisse pas utiliser Cache-Control :no-cache à cause de IE. Voir http ://support.microsoft.com/support/kb/articles/q316/4/31.asp
Pour être sûr que le navigateur redemande toujours le fichier, il faut ajouter le header expires à la requête. Vous
pouvez faire cela avec le module expires d’apache.
Activez le module comme ceci :
$ a2enmod expires
Et configurer apache pour que les fichiers avec le type mime application/x-zope-edit expirent au bout d’une seconde :
$ sudo vi /etc/apache2/httpd.conf
Ajoutez les lignes :
ExpiresActive On
ExpiresByType application/x-zope-edit A1
et rechargez apache :
$ sudo /etc/init.d/apache2 reload
Vous aurez les headers suivants de positionnés :
Cache-Control: max-age=1
Expires: (last modified date +1s)
Si vous avez le proxy cache varnish, configurez le pour ne pas mettre en cache les fichiers qui possède le type
mime application/x-zope-edit. En effet par défaut le fichier est caché pendant 120s, qui est le défaut ttl (time to
live).
Pour désactiver cela, ajoutez dans votre varnish.vcl, dans vcl_fetch la règle suivante :
156
Chapitre 14. Zope External Editor
Plone pour les intégrateurs, Version 1.0.0
if (obj.http.Content-Type == "application/x-zope-edit") {
pass;
}
L’utilisateur doit posséder les permissions WebDAV Lock items et WebDAV Unlock items pour pouvoir verrouiller
le document via External Editor.
14.4. Problèmes de cache avec l’External Editor
157
Plone pour les intégrateurs, Version 1.0.0
158
Chapitre 14. Zope External Editor
CHAPITRE 15
Monitoring avec Munin
– Plugins Zope
– Plugins Varnish
– Ressources
Installez le serveur et le client Munin :
$ apt-get install munin munin-node
À l’installation il active les plugins en fonction de ce qui installé :
apache_processes cpu df df_inode entropy forks if_err_eth0 if_err_eth1 if_eth0 if_eth1 interrupts
Vous aurez les plugins mysql si vous avez mysql-server d’installé. Les plugins actifs sont des liens symboliques
dans /etc/munin/plugins/.
Éditez /etc/munin/munin.conf pour changer host.domain.com :
# a simple host tree
[host.domain.com]
address 127.0.0.1
use_node_name yes
Activer d’autres modules si vous le souhaitez :
$ cd /etc/munin/plugins
$ ln -s /usr/share/munin/plugins/fail2ban
$ ln -s /usr/share/munin/plugins/smart_ smart_sda
Tous les fichiers dans /var/lib/munin et /var/log/munin doivent appartenir à l’utilisateur munin (à exécuter seulement si vous n’avez pas de stats) :
$ chown -R munin:munin /var/lib/munin /var/log/munin
Reexécutez cette commande si vous n’avez toujours pas de stats après 15 minutes.
Redémarrez munin-node pour reprendre en compte la configuration :
$ /etc/init.d/munin-node restart
159
Plone pour les intégrateurs, Version 1.0.0
15.1 Plugins Zope
Exemple de buildout de deploiement avec munin :
[buildout]
extends = buildout.cfg
parts +=
zeoserver
instance1
instance2
munin1
[hosts]
zeoserver
instance1
instance2
= 127.0.0.1
= 127.0.0.1
= 127.0.0.1
[ports]
zeoserver
instance1
instance2
= 8100
= 9880
= 9881
[instance-settings]
eggs =
${instance:eggs}
munin.zope
zcml =
${instance:zcml}
munin.zope
products = ${instance:products}
user = ${instance:user}
zodb-cache-size = 8000
zeo-client-cache-size = 300MB
debug-mode = off
zope2-location = ${zope2:location}
zeo-client = true
zeo-address = ${zeoserver:zeo-address}
effective-user = ${users:zope}
environment-vars = ${instance:environment-vars}
zserver-threads = 2
[instance1]
recipe = collective.recipe.zope2cluster
instance-clone = instance-settings
http-address = ${hosts:instance1}:${ports:instance1}
[instance2]
recipe = collective.recipe.zope2cluster
instance-clone = instance-settings
http-address = ${hosts:instance2}:${ports:instance2}
[munin1]
recipe = zc.recipe.egg
eggs = munin.zope
scripts = munin=munin1
arguments = ip_address=’${hosts:instance1}’, http_address=’${ports:instance1}’, user=’${instance1:
[munin2]
recipe = zc.recipe.egg
eggs = munin.zope
scripts = munin=munin2
arguments = ip_address=’${hosts:instance2}’, http_address=’${ports:instance2}’, user="${instance2:
160
Chapitre 15. Monitoring avec Munin
Plone pour les intégrateurs, Version 1.0.0
Installez les liens symboliques :
$ sudo ./bin/munin1 install /etc/munin/plugins instance1
installed symlink /etc/munin/plugins/instance1_zopecache_plonesite
installed symlink /etc/munin/plugins/instance1_zopememory_plonesite
installed symlink /etc/munin/plugins/instance1_zodbactivity_plonesite
installed symlink /etc/munin/plugins/instance1_zopethreads_plonesite
$ sudo ./bin/munin2 install /etc/munin/plugins instance2
installed symlink /etc/munin/plugins/instance2_zopecache_plonesite
installed symlink /etc/munin/plugins/instance2_zopememory_plonesite
installed symlink /etc/munin/plugins/instance2_zodbactivity_plonesite
installed symlink /etc/munin/plugins/instance2_zopethreads_plonesite
Redémarrez munin-node pour reprendre en compte la configuration :
$ /etc/init.d/munin-node restart
15.2 Plugins Varnish
Il existe des plugins munin pour Varnish. Voyez la page sur pypi pour les instructions :
http ://pypi.python.org/pypi/munin.varnish
Les plugins utilisent la commande varnishstat. Cette commande est disponible si vous avez le package
libncurses5-dev lors de la compilation de Varnish.
15.3 Ressources
–
–
–
–
http ://www.debianadmin.com/monitor-servers-and-clients-using-munin-in-ubuntu.htm
http ://www.debianhelp.co.uk/munin.htm
http ://www.debuntu.org/how-to-monitoring-a-server-with-munin
http ://www.debuntu.org/how-to-monitoring-a-server-with-munin-p2
15.2. Plugins Varnish
161
Plone pour les intégrateurs, Version 1.0.0
162
Chapitre 15. Monitoring avec Munin
CHAPITRE 16
PloneFormGen
– Présentation de PloneFormGen
– Qu’est ce que PloneFormGen ?
– Qu’est-ce que l’on peut faire avec PloneFormGen ?
– Installation de PloneFormGen
– Création d’un formulaire
– Les différents composants d’un formulaire
– Les différents types de champs
– Champ de type Checkbox
– Champ de type date et heure
– Champ de type decimal Number
– Champ de type conteneur pour groupe de champs
– Champ de type saisie multiple
– Champ de type sélection multiple
– Champ de type mot de passe
– Champ de type Rating-Scale Field
– Champ de type Rich Label Field
– Champ de type texte mis en forme
– Champ de type sélection
– Champ de type texte court
– Champ de type zone de texte
– Champ de type Whole Number Field
– Les adaptateurs pour scripts
– Les expéditeurs de méls
– Les enregistreurs de données
– La page de remerciement
– Exercice : Réalisation d’un formulaire de sondage
– Composition du formulaire
– Création de l’enregistreur pour récupérer les données au format CSV
– Création d’un script remplissant une base de données.
16.1 Présentation de PloneFormGen
16.1.1 Qu’est ce que PloneFormGen ?
PloneFormGen est un produit permettant la création en ligne de formulaire pour Plone.
On trouvera de la documentation sur http ://plone.org/products/ploneformgen/documentation
163
Plone pour les intégrateurs, Version 1.0.0
16.1.2 Qu’est-ce que l’on peut faire avec PloneFormGen ?
Outre la création à travers le web des formulaires, on pourra stocker les informations qui y seront saisies en vue
de les réutiliser et de les exporter au format csv.
De plus la possibilité de créer des adaptateurs appelant des scripts Python en fin de saisie permettent par exemple
de créer des instances de n’importe quel type de contenu et de les remplir à partir des informations préalablement
saisies.
16.1.3 Installation de PloneFormGen
Pour installer PloneFormGen le plus simple et de l’ajouter à son buildout.
Si vous ne savez pas ce qu’est un buildout vous pouvez lire le chapitre Introduction à zc.buildout et Création d’un
buildout Plone avec ZopeSkel.
Pour cela ajouter Products.PloneFormGen à la section egg de la partie instance :
[instance]
# ...
eggs =
# ...
Products.PloneFormGen
Refaites votre buildout, démarrez, puis ajoutez le produit.
16.1.4 Création d’un formulaire
La création d’un formulaire commence par la création d’un Form Folder ou Formulaire personnalisé en français
dans la liste Ajout d’un élément.
Vous obtenez alors :
Le formulaire spécialisé est un répertoire qui permet de définir votre formulaire et qui contiendra les éléments qui
vont le constituer.
Remarquez également la barre des propriétés qui va permettre d’accéder à la définition du comportement du
formulaire (onglet Overrides).
Saisissez un titre et une description.
Vous pouvez changer le nom des boutons de soumission ou d’annulation.
Par défaut le comportement d’un formulaire personnalisé est d’envoyer un mail avec les informations saisies par
les utilisateurs. Ce comportement est réalisé par un “adaptateur d’action” nommé “Gestionnaire de mél”. Par la
suite nous verrons comment remplacer cet adaptateur par celui que nous aurons créé.
Vous pourrez aussi définir une page de remerciement qui viendra remplacer celle par défaut qui se contente d’afficher les valeurs saisies dans le formulaire.
Pour des raisons de confidentialité vous pourrez forcer la saisie des informations via une connexion chiffrée à
condition d’avoir configurer votre serveur pour qu’il gère le ssl et donc d’avoir un certificat X509.
Vous pouvez ensuite saisir le prologue et l’épilogue du formulaire.
Enregistrez.
Vous êtes alors redirigé vers votre formulaire qui affiche le titre, la description, le prologue, les champs de saisie
“Votre adresse mél”, “Sujet”, et “Commentaires”, le bouton “Envoyer” et pour finir votre épilogue.
Nous verrons comment ajouter d’autres champs et supprimer ceux existants par défaut.
Si vous avez correctement configuré le mailhost de votre instance Plone, le résultat des formulaires sera envoyé
par mél à destination du contact “Adresse d’expéditeur des courriels pour le site” (modifiable en cliquant sur
Configuration du site puis Envoi de courriels).
164
Chapitre 16. PloneFormGen
Plone pour les intégrateurs, Version 1.0.0
F IG . 16.1 – Ajout d’un formulaire personnalisé.
16.1. Présentation de PloneFormGen
165
Plone pour les intégrateurs, Version 1.0.0
F IG . 16.2 – Vue d’un formulaire.
Après avoir appuyé sur Envoyer l’utilisateur est redirigé sur la page de remerciement qui récapitule les valeurs
entrées.
16.1.5 Les différents composants d’un formulaire
Cliquez sur l’onglet édition de votre formulaire puis cliquez sur l’onglet Overrides des propriétés.
F IG . 16.3 – Onglets d’accès aux propriétés d’un formulaire
Vous accédez alors à la page suivante :
Le champ “Action de validation personnalisée” permet d’exécuter un script personnalisé qui sera appelé après
l’action associée au formulaire (par défaut l’envoi de mél).
Le champ “Action personnalisée du formulaire” permet d’exécuter un script personnalisé en lieu et place de l’envoi
de mél.
Le champ “Script de configuration du formulaire” permet d’exécuter un script avant l’affichage du formulaire pour
par exemple remplir les champs avec des valeurs calculées.
Le champ “Script post-validation” permet d’exécuter un script ayant pour objectif de valider la cohérence des
valeurs saisies les une vis-à-vis des autres ou vis à vis de données extérieures.
Le champ “Injection de contenu d’entête” permet de compléter la page html avec par exemple des liens vers des
ressources css ou javascripts.
La case à cocher “CSRF Protection” permet d’éviter les liens html ou l’insertion de javascript lors de la saisie des
valeurs du formulaire.
166
Chapitre 16. PloneFormGen
Plone pour les intégrateurs, Version 1.0.0
F IG . 16.4 – Paramétrage du comportement d’un formulaire
16.1. Présentation de PloneFormGen
167
Plone pour les intégrateurs, Version 1.0.0
Plus d’informations sur l’overrides : http ://plone.org/products/ploneformgen/documentation/tutorial/customizingploneformgen
Pour ajouter des champs ou des actions il suffit de cliquer sur l’un des types disponibles depuis le menu Ajout
d’un élément.
F IG . 16.5 – Ajout d’un champ ou d’une action
Nous allons détailler les éléments de formulaire ci-après.
L’édition graphique et le placement se font après avoir cliqué sur l’icône d’accès à la vue de paramétrage.
F IG . 16.6 – Icône d’accès à la vue de paramétrage
On obtient alors une vue ressemblant à :
Les colonnes “Delete” permettent de supprimer les composants, les colonnes “Edit” permettent d’éditer le composant désigné par la ligne où nous avons cliqué. La colonne “Order” permet par drag and drop de déplacer les
champs pour en changer l’ordre alors que la colonne “Enable” permet d’activer ou non une action ou un page de
remerciement.
168
Chapitre 16. PloneFormGen
Plone pour les intégrateurs, Version 1.0.0
F IG . 16.7 – Paramétrage des éléments du formulaire
16.1. Présentation de PloneFormGen
169
Plone pour les intégrateurs, Version 1.0.0
16.1.6 Les différents types de champs
Champ de type Checkbox
L’ajout d’une checkbox permet de créer une checkbox.
F IG . 16.8 – Formulaire de paramétrage d’un champ de type checkbox
Signification des champs :
– Le label du champ correspond au nom du champ il doit être explicite,
– l’aide doit permettre à l’utilisateur de savoir à quoi sert ce checkbox,
– le champ obligatoire s’il est coché oblige l’utilisateur à se prononcer,
– la valeur par défaut (cochée ou non)
– la chaîne de caractères affichée si la checkbox est cochée,
– la chaîne de caractères affichée si la checkbox n’est pas cochée.
Comme pour le formulaire les champs possèdent une propriété “Overrides”.
170
Chapitre 16. PloneFormGen
Plone pour les intégrateurs, Version 1.0.0
F IG . 16.9 – Propriétés overrides des champs de type checkbox
16.1. Présentation de PloneFormGen
171
Plone pour les intégrateurs, Version 1.0.0
“Expression par défaut” permet de remplir le champ à partir d’une expression TALES évaluée lors du rendu du
formulaire, dans le cas du checkbox le résultat doit être “checked” ou la chaine vide “”.
“Validateur personnalisé” permet de saisir une expression TALES validant la saisie, attention généralement le test
ne concerne que la valeur du champ et non la cohérence du formulaire qui est réalisé dans le test de post validation.
“Enabling Expression” permet de griser ou non le champ à l’affichage en fonction du résultat de l’expression
TALES saisie.
Champ de type date et heure
L’ajout d’un champ date et heure permet de créer une zone de saisie année, mois, jour, heure, minute pouvant être
saisie par calendrier.
La valeur par défaut est saisie sous la forme AAAA MM JJ HH mm où les séparateurs peuvent être ‘ ‘, ‘/’, ‘-‘, ‘.’.
Champ de type decimal Number
Il permet de créer des champs de saisie de nombre flottant.
Champ de type conteneur pour groupe de champs
Il permet de créer un dossier qui contiendra des champs et les groupera visuellement à l’écran.
Remarquer que l’édition des champs contenus par le groupe nécessite de passer par la vue Contenus.
Champ de type saisie multiple
Il permet de créer une zone de saisie de lignes de texte.
Les propriétés Overrides offre en plus un champ “Server-Side Variable” qui permet d’utiliser le contenu du champ
pour passer des valeurs aux adaptateurs d’actions.
Champ de type sélection multiple
Overrides permet via le champ “Vocabulaire des options” de définir une expression TALES permettant de définir
le dictionnaire.
Champ de type mot de passe
Lors de la saisie les lettres seront remplacés par des ‘*’.
Champ de type Rating-Scale Field
Champ de type Rich Label Field
Ce champ permet de faire de la mise en forme.
Champ de type texte mis en forme
Champ de type sélection
Overrides permet via le champ “Vocabulaire des options” de définir une expression TALES permettant de définir
le dictionnaire.
172
Chapitre 16. PloneFormGen
Plone pour les intégrateurs, Version 1.0.0
Champ de type texte court
Champ de type zone de texte
Champ de type Whole Number Field
16.1.7 Les adaptateurs pour scripts
Les adaptateurs de scripts permettent de réaliser des actions sous forme de code Python.
Certaines restrictions de sécurité sont présentes, il n’est donc pas possible d’importer toutes les bibliothèques du
langages.
F IG . 16.10 – Édition de l’adaptateur de script
Le champ “proxy role” permet d’exécuter le script avec le rôle Administrateur.
Le champ “corps du script” permet de saisir le code Python.
La propriété Overrides permet de définir une “Condition d’exécution” qui si elle n’est pas vérifiée empêche l’exécution du script.
Exemple d’adaptateur créant un document à partir des données saisies :
#
#
#
#
#
#
#
#
#
#
Available parameters:
fields = HTTP request form fields as key value pairs
request = The current HTTP request.
Access fields by request.form["myfieldname"]
ploneformgen = PloneFormGen object
Return value is not processed -- unless you
return a dictionary with contents. That’s regarded
as an error and will stop processing of actions
and return the user to the form. Error dictionaries
16.1. Présentation de PloneFormGen
173
Plone pour les intégrateurs, Version 1.0.0
# should be of the form {’field_id’:’Error message’}
from Products.CMFCore.utils import getToolByName
portal = getToolByName(ploneformgen, ’portal_url’).getPortalObject()
putils = getToolByName(ploneformgen, ’plone_utils’)
title = fields[’topic’]
masaisie = fields[’ma-saisie’]
id=putils.normalizeString(title)
portal.invokeFactory(’Document’, id=id ,title=title,
text=u"\n".join(masaisie))
link=portal[id].absolute_url()
request.RESPONSE.redirect(link)
16.1.8 Les expéditeurs de méls
@TODO
16.1.9 Les enregistreurs de données
@TODO
16.1.10 La page de remerciement
@TODO
16.2 Exercice : Réalisation d’un formulaire de sondage
16.2.1 Composition du formulaire
@TODO
16.2.2 Création de l’enregistreur pour récupérer les données au format CSV
@TODO
16.2.3 Création d’un script remplissant une base de données.
@TODO
174
Chapitre 16. PloneFormGen
CHAPITRE 17
TAL/Metal les templates de Zope et
Plone
Les Zope Page Templates sont un mécanisme permettant d’écrire des pages xhtml dynamiques.
Ces ZPT utilise un langage de template XML TAL/METAL. L’objectif est d’être capable de comprendre, créer et
modifier les pages dynamiques.
175
Plone pour les intégrateurs, Version 1.0.0
– Le langage TAL
– Savoir
– TALES
– Savoir
– METAL
– Savoir
– Ressources
– Namespaces
– Variables globales
– Présentation des ZPT
– Le langage TAL
– Liste des commandes
– Ordre d’évaluation
– Content et Replace
– Condition
– Attributes
– Define
– Repeat
– On-error
– Omit-tag
– TALES
– Définition
– Exemples
– Path
– Path alternatif et nothing
– Not
– String
– Nocall
– Python
– METAL
– metal :define-macro
– metal :define-slot
– metal :use-macro
– metal :fill-slot
– Tips
– Exercice
17.1 Le langage TAL
17.1.1 Savoir
–
–
–
–
–
–
–
–
Liste des commandes
Ordre d’évaluation
Content et Replace
Condition
Define
Repeat
On-error
Omit-tag
176
Chapitre 17. TAL/Metal les templates de Zope et Plone
Plone pour les intégrateurs, Version 1.0.0
17.2 TALES
17.2.1 Savoir
–
–
–
–
–
–
–
Exemples
Path
Path alternatif et nothing
Not
String
Nocall
Python
17.3 METAL
17.3.1 Savoir
–
–
–
–
metal
metal
metal
metal
:define-macro
:define-slot
:use-macro
:fill-slot
17.4 Ressources
Lire la documentation ZPT - Zope Page Templates sur plone.org.
À noter que certains exemples avec tal :repeat sont faux.
Un tal :repeat sur une balise <ul ..> ou <tbody ...> répètera la balise à chaque tour de boucle. Le
tal :repeat devrait donc se situer sur un <li ...> ou un <tr ...>.
Petit rappel sur les tableaux : vous pouvez mettre un <tr> dans un <thead> pour avoir une ligne d’en-tête sur
chaque page lors de l’impression d’un tableau. Il va de même pour un pied de page avec la balise <tfoot>.
Dans le document ci-dessus, il manque les commandes tal :omit-tag et tal :on-error, cela est expliqué dans le ZopeBook :
– Using Zope Page Templates
– Advanced Page Templates
– Appendix C : Zope Page Templates Reference
La documentation sur plone.org et celle dans le ZopeBook se ressemble beaucoup. Les pages dans le ZopeBook
sont complémentaires à la documentation sur plone.org.
17.5 Namespaces
Prenez l’habitude de toujours inclure les namespaces dans vos templates. Ils seront nécessaires pour le nouveau
moteur de template Chameleon qui parse la page de manière stricte.
La structure minimale est donc :
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:tal="http://xml.zope.org/namespaces/tal"
xmlns:metal="http://xml.zope.org/namespaces/metal"
xmlns:i18n="http://xml.zope.org/namespaces/i18n"
xml:lang="en" lang="en"
metal:use-macro="context/main_template/macros/master"
i18n:domain="mydomain">
17.2. TALES
177
Plone pour les intégrateurs, Version 1.0.0
...
</html>
Vous pouvez vérifier si vos templates sont bien valides XML avec la commande xmllint matemplate.pt.
17.6 Variables globales
Dans Plone 3.3, vous avez accès à des variables et fonctions globalement dans vos pages templates. Vous n’y avez
pas accès via une vue zope3.
Vous
pouvez
récupérer
une
liste
des
Products.CMFPlone.browser.ploneview.
fonctions
disponibles
dans
le
module
Toutefois étant donné que dans Plone 4, vous n’y aurez plus accès, prenez l’habitude d’appeler ces fonctions
spéciales par l’intermédiaire d’une vue. Par exemple au lieu d’utiliser :
<span tal:content="python:toLocalizedTime(context.ModificationDate())">
modification date
</span>
utilisez plutôt :
<span tal:define="plone_view context/@@plone"
tal:content="python:plone_view.toLocalizedTime(context.ModificationDate())">
modification date
</span>
Les variables globales vont être supprimées dans Plone 4 pour des raisons de performances. En effet de nombreuses
variables sont accessibles depuis la template mais ne sont pas forcément utilisées, et donc il y a un traitement inutile
au rendu de la page.
Vous avez quatre vues intéressantes pour récupérer des informations :
– @@plone (toLocalizedTime...)
– @@plone_tools (properties pour récupérer portal_properties)
– @@plone_portal_state (navigation_root_url, is_locked, language, is_editable, object_url...)
– @@plone_context_state (portal_url...)
17.7 Présentation des ZPT
Objectif
Être capable de comprendre, créer et modifier les pages dynamiques.
Les Zope Page Template sont un mécanisme permettant d’écrire des pages XHTML dynamiques.
Elles sont constituées de page XHTML dans lesquelles sont inclus des balises et attributs TAL/METAL.
Exemple :
<html xmlns="http://www.w3.org/1999/xhtml"
xml:lang="en"
lang="en"
xmlns:tal="http://xml.zope.org/namespaces/tal"
xmlns:metal="http://xml.zope.org/namespaces/metal"
xmlns:i18n="http://xml.zope.org/namespaces/i18n"
metal:use-macro="here/main_template/macros/master"
i18n:domain="plone">
<head><title></title></head>
<body>
<metal:fill fill-slot="main">
<metal:main_macro define-macro="main">
178
Chapitre 17. TAL/Metal les templates de Zope et Plone
Plone pour les intégrateurs, Version 1.0.0
<div tal:content="python:1+3*7" />
</metal:main_macro>
</metal:fill>
</body>
</html>
17.8 Le langage TAL
Le texte d’origine est accessible à http ://www.sebastien-verbois.be/plone/zpt/zpt-am
Template Attribute Language (commandes possibles)
17.8.1 Liste des commandes
–
–
–
–
–
–
–
–
tal
tal
tal
tal
tal
tal
tal
tal
:content pour remplacer le contenu d’une balise ;
:replace pour remplacer toute la balise ;
:condition condition d’exécution du bloc ;
:attributes pour manipuler les attributs de la balise ;
:define pour définir des variables ;
:repeat pour faire une boucle ;
:omit-tag pour ne pas produire la balise elle-même ;
:on-error pour définir le comportement en cas d’erreur.
tal :content et tal :replace sont mutuellement exclusives.
Une commande ne peut apparaître qu’une seule fois dans une balise.
17.8.2 Ordre d’évaluation
define -> condition -> repeat -> (content | replace) -> attributes -> omit-tag
on-error est évalué si une exception est levée lors d’un traitement d’une des opérations ci-dessus.
17.8.3 Content et Replace
tal:content="[structure] Tales"
tal:replace="[structure] Tales"
Le contenu est automatiquement transformé à l’aide de la fonction html_quote. Pour ne pas subir cette transformation, il faut utiliser le préfixe structure.
Il est possible d’accéder aux informations portées par les itérations en utilisant la variable repeat.
17.8.4 Condition
tal:condition="Tales"
Tales est évalée à True ou False. Le nombre zéro, la chaîne vide, une liste vide et la variable nothing sont
évaluées à False.
17.8. Le langage TAL
179
Plone pour les intégrateurs, Version 1.0.0
17.8.5 Attributes
tal:attributes="NomAttribut1 Tales1; NomAttribut2 Tales2; ...; NomAttributN TalesN"
17.8.6 Define
tal:define="[global] NomVariable1 Tales1; [global] NomVariable2 Tales2; ...; [global] NomVariableN
17.8.7 Repeat
tal:repeat="NomVariable Tales"
Les itérations imbriquées sont possibles.
Les tales suivantes sont accessibles dans le bloc repeat :
– repeat/NomVariable/index : 0,1,...
– repeat/NomVariable/number : 1,2,...
– repeat/NomVariable/letter : a,b,...
– repeat/NomVariable/Letter : A,B,...
– repeat/NomVariable/roman : i,ii,...
– repeat/NomVariable/Roman : I,II,...
– repeat/NomVariable/even
– repeat/NomVariable/odd
– repeat/NomVariable/start
– repeat/NomVariable/end
– repeat/NomVariable/first
– repeat/NomVariable/last
17.8.8 On-error
tal:on-error="Tales"
La valeur de Tales est utilisée pour remplacer l’expression qui a levé une exception dans une autre TAL.
17.8.9 Omit-tag
tal:omit-tag=""
17.9 TALES
17.9.1 Définition
TAL Expression Syntax (language d’expression des opérations possibles)
Tales ::= [Type:]Suite
Type ::= path|string|python|not|exists|nocall
Si Type n’est pas donné, le type path est utilisé (type par défaut).
– path permet d’accéder au rendu d’un objet ou attribut disponible dans la pile d’acquisition de la template ;
– string permet de combiner une expression simple avec du texte ;
– python permet d’évaluer du code python ;
180
Chapitre 17. TAL/Metal les templates de Zope et Plone
Plone pour les intégrateurs, Version 1.0.0
– not permet d’effectuer une négation sur une expression path, string ou python ;
– nocall permet d’accéder à l’objet évalué plutôt qu’à son rendu ;
– exists permet de tester l’existence d’un attribut ou d’une méthode (même formalisme que path).
path, nocall et exists sont des expressions “path”.
Variables implicites :
– attrs
– container
– default
– context/here
– modules
– nothing
– options
– request
– root
– template
– user
Voir http ://plone.org/documentation/tutorial/zpt/ pour une description.
L’utilisation de here est dépréciée au profit de context.
17.9.2 Exemples
Path
–
–
–
–
–
–
–
path :context/title_or_id
path :context/bobobase_modification_time
path :container/objectValues
path :container/objectIds
path :user/getUserName
path :request/AUTHENTICATED_USER
path :request/URL
Path alternatif et nothing
– path :request/form/custname | context/custname | nothing
Not
– not :request/maVariable
String
string:Quelques mots !
On peut utilise une expression path dans une expression string en l’encadrant par ${}.
– string :Bienvenue ${user/getUserName} !
– string :$$ 30
Nocall
tal:define="doc nocall:here/monDocument" tal:content="string:${doc/id}: ${doc/title}"
17.9. TALES
181
Plone pour les intégrateurs, Version 1.0.0
Python
python:len(container.objectValues([’File’,’Image’]))
python:context.bobobase_modification_time.strftime(’%d/%m/%Y’)
python:test(nombre/2,’Nombre pair’,’Nombre impair’)
python:context.monScript(arg1,arg2)
Possibilité d’utiliser les autres types d’expressions au sein d’une expression python à l’aide des fonctions path(),
string(), exists(), nocall().
python:path(’here/%s/title_or_id’ % currentfolder)
python:path(string(’here/$foldername/thing’))
python:path(’request/form/x’) or default
Accéder à des objets zope
python:getattr(here,’penguin.gif’) (== path:here/penguin.gif)
python:request[’URL’] (== path:request/URL)
python:request.form[’x’] (== path:request/form/x)
python:modules[’math’]
17.10 METAL
Macro Expansion Template Attribute Language (système de macros)
metal:define-macro
metal:define-slot
metal:use-macro
metal:fill-slot
17.10.1 metal :define-macro
Permet de définir une macro que l’on pourra appeler par metal=use-macro.
17.10.2 metal :define-slot
Permet de définir un connecteur dans une macro qui permettra d’insérer du code lors de l’expansion de la macro.
17.10.3 metal :use-macro
Permet d’indiquer que l’on souhaite utiliser une macro définie dans une ZPT.
Ainsi <div metal :use-macro="here/main_template/macros/master"> va chercher la macro
master définie dans la ZPT main_template.
182
Chapitre 17. TAL/Metal les templates de Zope et Plone
Plone pour les intégrateurs, Version 1.0.0
17.10.4 metal :fill-slot
Permet d’insérer du XHTML dans l’espace prévue pour cela dans une macro.
Ainsi <metal :fill fill-slot="main">Mon contenu</metal :fill> permet d’insérer “Mon
contenu” dans la partie metal :define-slot="main" de la zpt appelée par metal-use-macro.
Tips
Utiliser default
<p tal:content="request/form/info | default">Pas de variable "info" dans la requête.</p>
Afficher du texte dans la template qui ne sera pas rendu par la suite
tal:replace="nothing"
Choisir la classe d’une entité
tal:attributes="class python:test(...,’selected’,’plain’)"
Utilisation d’un dictionnaire dans les expressions path
getPerson est une fonction python qui renvoie le dictionnaire {’name’ : ’Toto’, ’age’ : 8}.
Accéder à des modules python
tal:define="global mstring modules/string" tal:replace="python:mstring.join(slist, ’:’)"
Module “PythonScripts” de Zope
tal:define="pps modules/Products.PythonScripts.standard"
Gérer une exception
<p>Le prix de l’article est <b tal:content="context/prix" tal:on-error="string:N/A">0.00</b> Euros
17.11 Exercice
– Customisation de la template model9 de PloneArticle pour supprimer “ajouter images” et “ajouter liens”.
From Raphael Ritz at http ://n2.nabble.com/where-do-I-find-the-view-template-to-edit-a-page-%28plone3.2%29-tp2975276p2979777.html :
atct_edit is just a wrapper around base_edit (or whatever gets called from base_edit) to allow for
atct specific form controller settings without interfering with Archetypes proper. base_edit in turn pulls in the
macros from edit_macros (in the archetypes skin layer) unless you (or someone) provides any of those
macros specifically (like via a <type_name>_view/edit template).
http ://www.llakomy.com/articles/new-submit-button-for-archetypes-edit-template
17.11. Exercice
183
Plone pour les intégrateurs, Version 1.0.0
184
Chapitre 17. TAL/Metal les templates de Zope et Plone
CHAPITRE 18
Paramétrage local des workflows
–
–
–
–
–
–
Préparation
Installation du module
Gestion des politiques de workflow
Affectation des workflows locaux
Export Generic Setup
Conclusion
Nous allons montrer ici comment affecter, sous Plone 4, des processus documentaires différents selon les rubriques
du site.
Imaginons que nous voulons gérer une partie Intranet et une partie Internet sur notre site Plone. Les permissions
et les circuits de validation ne seront probablement pas les mêmes.
Nous allons donc gérer, grâce à la fonctionalité Support des politiques documentaires locales, un dossier Intranet
dans lequel les documents auront un workflow de type Intranet (les membres peuvent soumettre des documents à
un modérateur, qui publie pour tous les membres), et un dossier Internet, où les documents auront un workflow
avec modération a priori (les membres peuvent soumettre des documents à un modérateur, qui publie soit pour les
anonymes soit pour les seuls membres).
18.1 Préparation
Connectez vous en tant qu’administrateur du site.
Avant de commencer, vous aurez créé à la racine un dossier Intranet et un dossier Internet, que vous aurez publié.
Dans chacun de ces dossiers, vous aurez ajouté une actualité, sans la publier.
18.2 Installation du module
Le système de workflows locaux n’est pas activé par défaut. Nous allons commencer par installer la fonctionnalité.
Allez dans configuration du site, puis modules.
Vérifiez si la ligne Support des politiques documentaire locales (CMFPlacefulWorkflow) apparaît pas dans Modules disponibles. Sinon, vérifiez qu’elle n’est pas déjà dans Modules installés : dans ce cas, passez à l’étape
suivante.
Cochez la ligne Support des politiques documentaire locales (CMFPlacefulWorkflow) dans Modules disponibles,
et cliquez sur Activer.
185
Plone pour les intégrateurs, Version 1.0.0
186
Chapitre 18. Paramétrage local des workflows
Plone pour les intégrateurs, Version 1.0.0
18.2. Installation du module
187
Plone pour les intégrateurs, Version 1.0.0
Le module est maintenant installé.
18.3 Gestion des politiques de workflow
Revenez dans la configuration du site. Dans Configuration de module, cliquez sur la nouvelle entrée : Politiques
documentaires.
Les listes de politiques documentaires existantes par défaut sont affichées.
Il existe déjà une politique ‘Intranet’. Pour en connaître les détails, cliquez sur le titre.
Ce que vous voyez est en fait une version simplifiée de la page de configuration du workflow général, dans la zmi
> portal_workflows. Référez vous à la formation sur les workflows pour davantage d’informations.
Vous pouvez sélectionner le workflow par défaut, et éventuellement un workflow spécifique par type de contenu
(en général on utilise des workflows différents pour les contenus de type rubrique). Les différents workflows disponibles sont ceux décrits dans portal_workflows, onglet ‘Contents’. Référez vous à la formation sur les workflows
pour retrouver comment ajouter et modifier des workflows existants.
Cette configuration conviendra pour notre partie Intranet. Revenons à la page principale de configuration des
processus en cliquant sur “Aller au niveau supérieur”.
Nous pourrions vérifier parmi les trois autres workflows disponibles s’il y en a qui pourraient correspondre à notre
besoin pour la partie Internet. Mais nous allons créer une nouvelle politique pour les besoins de cette formation.
Entrez internet dans le champ Nouvelle politique documentaire, puis cliquez sur Ajouter.
Donnez lui pour titre Publication Internet.
188
Chapitre 18. Paramétrage local des workflows
Plone pour les intégrateurs, Version 1.0.0
18.3. Gestion des politiques de workflow
189
Plone pour les intégrateurs, Version 1.0.0
190
Chapitre 18. Paramétrage local des workflows
Plone pour les intégrateurs, Version 1.0.0
Nous allons choisir, pour les documents, un Processus de publication simple, qui consiste en un circuit privé ->
en attente de validation -> publié pour tous. Pour cela, nous sélectionnons cette valeur pour le champ Processus
documentaire par défaut.
Pour tous les documents sauf Dossier et Collection, nous choisissons Processus par défaut de la politique, qui
renvoit à la valeur choisie ci-avant. Imaginons que dans le cas de notre site Internet, nous n’ayons pas besoin
de valider les dossiers vu que seul l’administrateur pourra en ajouter. Nous choisirons alors un workflow à un
seul état : le dossier est immédiatement publié, seul son contenu est modéré. Nous choisissons donc Processus de
publication à état unique. Supposons que nous voulons que la gestion des Collections soit identique sur le dossier
Internet et au niveau du site. Nous choisirons Acquisition du processus dans les dossiers parents pour Collection :
le workflow sera le même que pour le dossier parent (le site Plone).
Vous pouvez maintenant cliquer sur Enregistrer. Votre politique a été ajoutée.
18.4 Affectation des workflows locaux
Nous allons maintenant associer des workflows différents pour les actualités selon que nous sommes sur l’intranet
ou sur l’internet. Allez dans le dossier Intranet. Cliquez sur le menu État, puis Politique locale.
L’affectation locale des workflows n’est pas activée par défaut dans ce dossier. Vous arrivez donc sur une page
intermédiaire. Cliquez sur Ajouter une configuration locale des politiques documentaires dans le Dossier.
Vous arrivez sur la page de configuration locale des processus. Vous choisissez ici quelle est la politique que vous
voulez activer pour ce Dossier. Sélectionnez dans Pour ce dossier : Intranet, puis enregistrez.
Vous pouvez également faire en sorte que la politique soit associée à tous les sous-dossiers du dossier Intranet,
mais pas au dossier Intranet lui-même. C’est utile, par exemple, quand vous voulez des droits et des validations
différents pour les modifications à la racine de votre rubrique. Dans ce cas, vous choisirez la politique dans En
dessous de ce dossier.
Revenez dans le dossier Intranet. Ce dossier est maintenant en ‘Brouillon interne’ : il est modifiable par les modérateurs et visible par les membres). Si vous vous déconnectez, vous observerez qu’il n’est plus visible aux
anonymes.
Allez sur l’actualité. Vous observerez que les transitions proposées correspondent au workflow Publication internet : en tant qu’administrateur, je peux Publier en interne, c’est-à-dire rendre visible aux membres seulement.
Allez maintenant sur le dossier Internet. Cliquez sur État -> Politique locale. Faites de même, mais sélectionnez
Pour ce dossier -> Publication Internet.
Le dossier est resté à l’état ‘Publié’, mais vous observerez qu’aucune autre transition n’est disponible : nous
utilisons pour les dossiers le workflow Processus de publication à état unique.
Allez dans l’actualité. Vous avez en tant qu’administrateur le choix entre Publier et Soumettre à la publication.
Nous utilisons ici le workflow Processus de publication simple.
18.5 Export Generic Setup
Les politiques documentaires peuvent être exportées en xml via l’outil Generic Setup.
Dans portal_setup > Export, sélectionnez Placeful Workflow Policies puis Export selected steps.
L’outil ne permet pas d’exporter la configuration des politiques locales.
18.6 Conclusion
Nous savions déjà que nous pouvions avoir des processus documentaires différents suivant le type de contenu.
Nous savons maintenant que Plone permet de paramétrer des workflows différents pour un même type de contenu
18.4. Affectation des workflows locaux
191
Plone pour les intégrateurs, Version 1.0.0
192
Chapitre 18. Paramétrage local des workflows
Plone pour les intégrateurs, Version 1.0.0
18.6. Conclusion
193
Plone pour les intégrateurs, Version 1.0.0
mais à différents endroits du site.
Pour conclure, il faut prendre garde à distinguer trois notions, que nous définirons ici :
Processus de publication, ou workflow : c’est la description d’un processus de validation, avec états, transitions,
permissions... On les définit dans la ZMI, dans portal_workflows > Contents.
Politique documentaire : c’est la configuration des workflows pour tous les types de documents du site. On définit la politique par défaut sur la page d’accueil de portal_workflows, et des politiques supplémentaires dans
Configuration du site > Politiques documentaires.
Politique locale : c’est la sélection d’une politique documentaire pour qu’elle s’applique sur une rubrique du site.
On les définit via l’action État > Politique locale sur la rubrique.
194
Chapitre 18. Paramétrage local des workflows
CHAPITRE 19
Déclenchement d’événements avec
les règles de contenu
Plone permet de gérer des déclenchements d’actions avec un très haut niveau de paramétrage, suivant :
– un événement déclencheur (ajout d’un document, d’un utilisateur, passage d’une transition...),
– une / des conditions (état du document, type de document, rôle de l’utilisateur...),
– la localisation sur le site.
Les événements peuvent lancer des actions diverses telles que :
– envois d’emails,
– ajout de log,
– affichage d’un message,
– etc.
–
–
–
–
–
–
–
–
–
–
–
–
–
Objectif de la formation
Préparation
Créer une règle
Paramétrer une règle
Créer une condition
Créer une action
Activer la règle pour une partie du site
Tester la règle
Exemple 2 : Logguer les suppressions de documents
Exemple 3 : Déplacer les événements dans un même dossier, où qu’ils soient ajoutés
Export Generic Setup
Extensibilité
Conclusion
19.1 Objectif de la formation
Nous allons créer :
– une règle qui affiche un message à l’utilisateur et envoie un mail au modérateur lorsqu’une actualité est soumise
à validation dans la partie Intranet,
– une règle qui ajoute une entrée dans les logs à chaque fois qu’un document est supprimé,
– une règle qui déplace tous les événements ajoutés dans la partie Internet dans le dossier Événements.
195
Plone pour les intégrateurs, Version 1.0.0
19.2 Préparation
Il nous faudra un dossier Intranet et un dossier Internet à la racine de notre site (cf. chapitre précédent).
Il faut créer un utilisateur Modérateur Intranet qui ait le rôle Peut Modérer sur le dossier Intranet. Le smtp et
l’email par défaut du site doivent être correctement configurés.
19.3 Créer une règle
Créons la première règle citée ci-dessous.
Pour cela, connectez vous en administrateur, puis allez sur admin > Configuration du site. Cliquez sur ‘règles’.
Vérifiez tout d’abord que la case Activer globalement a bien été cochée. Elle a pour effet d’activer tout le système
de règles. Lorsque vous avez besoin de désactiver provisoirement toutes les règles, le mieux est de décocher cette
case.
Cliquez ensuite sur Ajouter une règle.
Choisissez comme titre : Une actualité a été ajoutée.
Il faut vérifier si la règle s’applique à chaque fois qu’un utilisateur effectue une transition. Sélectionnez comme
déclencheur Workflow state changed.
Puis enregistrez. La règle a été ajoutée. Elle apparaît maintenant dans la liste des règles.
Mais pour l’instant, elle ne se déclenche jamais, et ne fait rien... Il faut la paramétrer.
19.4 Paramétrer une règle
Cliquez sur la règle, vous arrivez à la page de paramétrage de cette règle.
196
Chapitre 19. Déclenchement d’événements avec les règles de contenu
Plone pour les intégrateurs, Version 1.0.0
19.4. Paramétrer une règle
197
Plone pour les intégrateurs, Version 1.0.0
Il nous faut maintenant ajouter les conditions de la règle, et ses résultats.
19.5 Créer une condition
La règle a deux conditions : il doit s’agir d’une actualité, et la transition doit être une soumission à la publication.
Dans la partie Si toutes les conditions suivantes sont remplies, sélectionnez Content type (Type de contenu), et
Ajouter
Choisissez le type de contenu Actualité, puis enregistrez. La condition a été ajoutée.
De même, ajoutez la condition sur la transition : sélectionnez Ajouter une transition > Workflow transition puis
Ajouter. Choisissez Submit for publication puis enregistrez.
19.6 Créer une action
On veut que le modérateur reçoive un mail. Pour Effectue les actions suivantes, sélectionnez Ajouter une action >
Send email, puis Ajouter.
Vous arrivez sur la page de paramétrage de l’email. Vous définissez ici le sujet, le texte, les destinataires, etc, en
utilisant un certain nombre de variables fournies de base par Plone.
198
Chapitre 19. Déclenchement d’événements avec les règles de contenu
Plone pour les intégrateurs, Version 1.0.0
Indiquez le sujet de l’email : L’actu ${title} est en attente de votre validation. L’emplacement ${title} sera remplacé par le titre du document au moment de l’envoi.
Comme source du courriel, ne mettez rien : ainsi, la source sera l’adresse du portail.
Comme destinataires, utilisez la variable ${reviewer_emails} : le mail sera envoyé à la liste des modérateurs
(Reviewers)
Entrez enfin un message comme sur cette copie d’écran :
Enregistrez ; votre action a été ajoutée.
Imaginons que les contributeurs de l’intranet craignent que leur demande ne soit pas prise en compte. Nous allons
ajouter un message leur indiquant que les modérateurs ont reçu un mail.
Faites Ajouter une action > Notify user, puis Ajouter.
Indiquez comme message : Les modérateurs ont été notifiés par mail de votre demande., conservez info comme
type de message, puis enregistrez.
Votre règle a été créée. Il reste maintenant à l’activer dans la partie Intranet du site.
19.7 Activer la règle pour une partie du site
Allez dans la rubrique Intranet, sélectionnez l’onglet Règles.
Vous avez un champ Affecter une règle ici qui propose (uniquement, pour l’instant) la règle Une actualité a été
ajoutée. Cliquez sur Ajouter.
Ceci fait, la règle est maintenant activée pour ce dossier, et seulement celui-ci. Pour l’activer sur tous les sousdossiers de l’intranet, cochez la règle dans le tableau et cliquez sur Appliquer aux sous-dossiers.
Vous pouvez activer / désactiver la règle ici. Si vous l’avez associée à d’autres dossiers via d’autres onglets règles,
seul celui-ci est impacté.
19.7. Activer la règle pour une partie du site
199
Plone pour les intégrateurs, Version 1.0.0
200
Chapitre 19. Déclenchement d’événements avec les règles de contenu
Plone pour les intégrateurs, Version 1.0.0
19.7. Activer la règle pour une partie du site
201
Plone pour les intégrateurs, Version 1.0.0
19.8 Tester la règle
Cliquez sur l’onglet Voir, puis sur une actualité du dossier. Soumettez à la publication le document.
Vous observerez que le message Les modérateurs ont été notifiés par mail de votre demande. apparaît bien. Et le
modérateur a reçu un courriel.
19.9 Exemple 2 : Logguer les suppressions de documents
Dans Configuration du site > Règles, cliquez Ajouter une règle.
Appelez-la Un document a été supprimé, choisissez le déclencheur Object removed from this container et enregistrez.
Cliquez sur la règle pour paramétrer les actions.
202
Chapitre 19. Déclenchement d’événements avec les règles de contenu
Plone pour les intégrateurs, Version 1.0.0
Nous ne spécifierons pas de conditions particulières ici. Sélectionnez Ajouter une action > Logger puis Ajouter.
Remplacez le Message par Suppression du document &c.
Allez à la racine du site et cliquez sur Règles ; ajoutez la règle Un document a été supprimé. Activez-la pour les
sous-dossiers.
Ajoutez un document sur le site, et supprimez-le. Si votre site est démarré en mode foreground, vous pouvez y
voir le log.
Sinon, consultez vos logs avec la commande tail -f ./var/log/instance.log depuis la racine du
buildout.
19.10 Exemple 3 : Déplacer les événements dans un même dossier, où qu’ils soient ajoutés
Imaginons que nous voulions regrouper tous les événements du site dans un seul dossier, sans contraindre l’utilisateur à être à un endroit particulier du site lorsqu’il ajoute un tel élément.
Ajoutez une nouvelle règle, que vous appelerez Un événement a été ajouté, avec le déclencheur Object added to
this container.
Associez-lui la condition : Type de contenu : Événement.
Ajoutez ensuite l’action Move to folder, et choisissez le dossier Événements.
Au niveau du dossier Internet, activez cette règle, et rendez-la applicable à tous les dossiers.
Dans ce même dossier, ajoutez un événement. Allez ensuite dans le dossier Événements, vous verrez qu’il y a été
déplacé. Revenez dans le dossier Internet : il n’y est plus.
19.11 Export Generic Setup
Les règles de contenu peuvent être exportées en xml via l’outil Generic Setup.
Dans portal_setup > Export, sélectionnez Content rules puis Export selected steps. Cela exporte à la fois vos
définitions de règles et les activations des règles sur les rubriques.
19.10. Exemple 3 : Déplacer les événements dans un même dossier, où qu’ils soient ajoutés203
Plone pour les intégrateurs, Version 1.0.0
Attention : après l’export, vérifiez que l’indentation automatique du xml n’a pas ajouté des espaces non désirés
dans vos messages.
19.12 Extensibilité
Les règles de contenu sont largement extensibles. Il est possible d’ajouter ou créer :
– de nouveaux déclencheurs,
– de nouvelles conditions,
– de nouvelles actions.
Si
vous
avez
des
besoins
spécifiques,
recherchez
sur
pypi
trules
pour
vérifier
si
une
extension
existe
pour
votre
http ://pypi.python.org/pypi ?%3Aaction=search&term=contentrules&submit=search.
le
cas
mot-clé
contend’utilisation
:
Vous pouvez également vous lancer dans le développement de conditions et actions (niveau avancé) avec l’aide
de ce guide http ://plone.org/documentation/kb/creating-content-rule-conditions-and-actions. Ou contactez votre
prestataire Plone favori.
19.13 Conclusion
Il est possible d’associer à un événement du site et suivant des conditions, sur des parties déterminées du site, des
actions. Un certain nombre de déclencheurs, d’actions et de conditions sont disponibles par défaut. D’autres sont
disponibles en tant qu’extensions. Il est aisé à un développeur d’en créer de nouveaux.
204
Chapitre 19. Déclenchement d’événements avec les règles de contenu
CHAPITRE 20
Créer des pages composées en ligne
avec Collage
Collage permet de composer en ligne, comme des contenus, des pages complexes composées d’éléments organisés
en grille. C’est le moyen idéal de permettre à un webmaster de gérer lui-même ses pages d’accueil.
–
–
–
–
–
–
–
–
–
Préparation
Objectif de la formation
Installer Products.Collage
Créer un Collage
Ajouter les éléments du Collage
Utiliser le collage comme page d’accueil
Paramétrer l’affichage du collage
Extensibilité
Conclusion
20.1 Préparation
Vous n’aurez besoin sur votre site que d’un dossier et de quelques actualités publiées.
20.2 Objectif de la formation
Nous allons associer comme page par défaut d’un dossier une page composée d’une collection d’actualités, d’une
image et d’une actualité complète.
20.3 Installer Products.Collage
Ajoutez à l’entrée eggs de votre buildout la valeur Products.Collage. Relancez le buildout puis redémarrez votre
site. La dernière version du package Products.Collage a été ajoutée à votre environnement Plone.
Il faut maintenant activer le module. Connectez vous en tant qu’administrateur. Allez dans admin > Configuration
du site, puis Modules. Cochez Products.Collage, puis enregistrez.
205
Plone pour les intégrateurs, Version 1.0.0
20.4 Créer un Collage
Allez dans un dossier de votre site, faites Ajout d’un élémént > Collage.
Indiquez un titre et enregistrez. Cliquez sur Composer pour aller sur la page de construction du collage.
Un collage se compose de rangées elles-mêmes divisiées en colonnes, chaque colonne pouvant contenir plusieurs
éléments les uns au-dessus des autres. Ajoutez une première rangée.
Cela ajoute une rangée, contenant par défaut une colonne.
20.5 Ajouter les éléments du Collage
Nous allons composer un collage en deux colonnes sur une ligne. L a première colonne contiendra une liste des
actualités, la seconde contiendra une image statique et le rendu d’une actualité.
Cliquez sur créer une colonne. Nous avons maintenant deux colonnes.
Dans la colonne de droite, cliquez sur Insérer un élément existant. Recherchez une actualité et insérez-la.
Vous avez créé un alias sur votre composition, qui affiche le contenu de votre actualité.
Vous pouvez créer un contenu spécifique pour votre composition. Dans la colonne de droite, cliquez sur Créer un
nouvel élément -> Image.
Vous arrivez sur le formulaire de création d’une image. Uploadez une image et publiez-la. Vous observez que la
nouvelle image est un contenu image qui a été ajouté dans un contenu colonne, lui même ajouté dans un contenu
rangée.
Cliquez sur Retour au collage.
Vous souhaitez que l’image s’affiche au-dessus du texte de l’actualité. Cliquez sur la flèche haut de l’image (ou la
flèche bas de l’actualité).
Vous avez changé l’ordre des éléments de la colonne.
206
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
20.5. Ajouter les éléments du Collage
207
Plone pour les intégrateurs, Version 1.0.0
208
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
20.5. Ajouter les éléments du Collage
209
Plone pour les intégrateurs, Version 1.0.0
Vous observerez que vous avez directement accès à certaines fonctionnalités des documents, comme par exemple,
la rotation des images (transformer), la copie, etc.
Nous allons créer une collection des actualités dans la colonne de gauche. Faites Créer un nouvel élément >
Collection.
Créez une collection qui affiche toutes les actualités du site. Revenez ensuite au Collage.
Cliquez sur Voir pour observer le résultat.
20.6 Utiliser le collage comme page d’accueil
Publiez le collage, puis assignez-le comme vue par défaut du dossier : sur le dossier, cliquez sur Affichage >
Changer la vue par défaut et sélectionnez votre collage.
Nous ne voulons pas faire apparaître le titre de notre collage Accueil internet sur cette page d’accueil. Allez dans
Modifier > Paramètres. Décochez Afficher le titre et enregistrez.
20.7 Paramétrer l’affichage du collage
Nous allons maintenant tester quelques options de paramétrage de notre collage. Nous pouvons choisir un modèle
pour notre ligne. Sur la ligne, cliquez modèle. Vous avez une liste de layouts disponibles.
Sélectionnez par exemple Gauche large.
Le résultat est manifeste (mais pas forcément très bon... re-sélectionnez le modèle Automatique).
210
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
20.7. Paramétrer l’affichage du collage
211
Plone pour les intégrateurs, Version 1.0.0
212
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
20.7. Paramétrer l’affichage du collage
213
Plone pour les intégrateurs, Version 1.0.0
Nous pouvons également choisir un modèle pour les éléments. Cliquez sur modèle de l’actualité, choisissez portlet.
La vue portlet permet de choisir un habillage.
20.8 Extensibilité
Il est possible de développer de nouveaux layouts et de nouveaux types d’éléments pour les compositions de
Collage.
Pour
trouver
les
modules
d’extension
existants,
cherchez
http ://pypi.python.org/pypi ?%3Aaction=search&term=collective.collage&submit=search.
sur
pypi
:
Dans la liste des modules disponibles pour collage, nous avons le produit collective.collage.portlet. C’est un plugin
collage qui nous permet d’avoir des portlets dans notre collage. Nous allons l’installer.
Dans votre buildout.cfg, ajoutez à votre paramètre eggs la valeur collective.collage.portlet. Relancez votre buildout
et redémarrez le site.
Allez dans configuration du site, et installez le module collective.collage.portlet.
Retournez sur votre collage. Ajoutez une colonne. Cliquez sur modèles. Un modèle a été ajouté au modèle standard : portlets. Choisissez-le.
La colonne fournit maintenant une interface permettant de sélectionner une portlet, similaire à celle de la page
‘Gérer les portlets’.
Ajoutez une portlet de modération, et enregistrez.
S’il n’existe pas de plugin correspondant à vos besoins, contactez votre prestataire Plone favori :).
20.9 Conclusion
Le module collage permet de créer des pages composées.
214
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
20.9. Conclusion
215
Plone pour les intégrateurs, Version 1.0.0
216
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
20.9. Conclusion
217
Plone pour les intégrateurs, Version 1.0.0
218
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
20.9. Conclusion
219
Plone pour les intégrateurs, Version 1.0.0
220
Chapitre 20. Créer des pages composées en ligne avec Collage
Plone pour les intégrateurs, Version 1.0.0
On organise des contenus en lignes et en colonnes. Ces contenus peuvent être des alias de documents du site, des
collections, ou des contenus embarqués.
On peut présenter les éléments de la composition suivant différents modèles, voire avec différents habillages.
Ces compositions sont idéales pour construire des pages d’accueil de sites ou de rubriques.
Des plugins existent pour étendre les éléments disponibles pour vos compositions.
20.9. Conclusion
221
Plone pour les intégrateurs, Version 1.0.0
222
Chapitre 20. Créer des pages composées en ligne avec Collage
CHAPITRE 21
Glossaire
Définition des termes et abréviations utilisés dans ce document.
adapter Classe Python fournissant aux objets exposant une certaine interface des services supplémentaires, sans
utiliser directement la technologie d’héritage Python. Les adapteurs font partie des concepts amenés par la
ZCA (Zope Component Architecture).
adaptateur Traduction libre de adapter.
AT Abréviation courante d’Archetypes utilisée dans les documentations, blogs, mailing-lists, forums ayant trait
à Plone.
brain Toute requête au catalogue fournit une itération de brains. Chaque brain étant une référence à un élément
de contenu, et incorpore la copie de certains attributs de celui-ci (titre, description, ...). cheeseshop voir pypi.
buildout Buildout – ou zc.buildout – est un outil multi-plateformes conçu pour installer et paramétrer les différents composants logiciels d’un système d’informations. Plone est installable par ce mode depuis sa version
2.5. zc.buildout permet en outre de personnaliser l’installation des composants qui concourent à l’installation de “votre” site Plone en modifiant son fichier de configuration. Le packaging sous forme d’eggs est
favorisé.
C Langage compilé de bas niveau utilisé pour coder - entre autres - Linux et Python. Un compilateur C est
nécessaire pour installer Zope ainsi que de nombreuses extensions Python.
component Package Python fournissant des fonctionnalités supplémentaires à Zope ou Plone. Les composants
sont installés le plus souvent dans $INSTANCE_HOME/lib/python, et plus généralement dans les répertoires du système de fichiers désignés par la directive path du fichier de configuration de votre instance
Zope. L’extension de Zope ou Plone par composants est la méthode recommandée pour faciliter la future
migration vers le pur Zope 3. Attention, si un composant comporte des directives ZCML, celui-ci doit être
déclaré dans la configuration de de votre instance Zope.
composant Traduction libre de component.
configlet Panneau de configuration de Plone permettant de paramétrer de façon globale certains aspects de Plone.
Par exemple, le panneau de configuration des utilisateurs et des groupes ou le thème graphique. Certains
composants d’extension de tierce partie ajoutent leur panneau de configuration.
content type Un type de contenu est le moule avec lequel tous les élément d’un certain type sont gérés. Un type
de contenu incorpore les dispositifs suivant :
– factory de création de l’élément
– vues HTML de l’élément schéma d’informations portées par l’élément, incluant ses méta-données
– formulaires de création/modification de ce schéma d’informations
– services “métier” proposés par l’élément.
distribute Distribute est une refonte et une alternative à setuptools élaborée à l’initiative de Tarek Ziadé.
distribute fournit les outils de packaging, de distribution et d’installation de packages Python sous
forme d’egg.
Nous recommandons vivement l’utilisation de distribute dont les contributeurs sont bien plus réactifs
que ceux de setuptools. Bien entendu, distribute est packagé sous forme d’egg.
223
Plone pour les intégrateurs, Version 1.0.0
distutils distutils est un package fourni en standard avec Python fournissant les outils de packaging. distribute s’appuie sur distutils et on préfèrera l’utilisation de ce dernier qui fournit des outils plus avancés.
dotted name Il n’y a pas de traduction en français facile et concise pour ce terme. Un dotted name permet
- généralement dans un fichier ZCML - de désigner un symbole Python quelconque (objet, classe, fonction,
...) sous la forme d’une chaîne de caractères proche de celle utilisée par le mot clé Python import. Par
exemple, le dotted name foo.bar.stuff représente l’équivalent en python from foo.bar import
stuff.
En outre, la notation dotted name admet la notation de package relatif par l’utilisation du préfixe ..
Par exemple .foo.bar dans un fichier ZCML permet de référencer l’objet (classe, fonction, ...) bar du
module foo.py lorsque ce module figure dans le même répertoire que le fichier ZCML. Un préfixe de
deux points (..) permet d’accéder au répertoire parent de celui incluant le fichier ZCML et ainsi de suite.
egg Packaging d’un module Python incluant ses méta-données telles que sa version, sa documentation et les
éventuelles dépendances d’autres eggs. La grande majorité des eggs publics sont distribués sur le site pypi.
Reportez-vous au chapitre Concept de Python eggs pour plus de détails.
eggs Voir egg.
élément (de contenu) ou “content item”. Unité atomique de contenu fournie par un auteur, tel qu’un document,
une image, un fichier. Certains types d’éléments, tel que le dossier ou la collection sont dits également conteneurs ou “folderish” de par leur aptitude à contenir d’autres éléments de la même façon qu’un répertoire
peut inclure d’autres fichiers et répertoires dans un disque dur.
groupe (d’utilisateurs). Un groupe d’utilisateurs permet d’associer un ensemble d’utilisateurs à une fonction
dans un site Plone. Ceci permet - principalement - d’octroyer des droits particuliers, élément par élément,
à tout un ensemble d’individus par le biais de l’onglet partage. Les groupes d’utilisateurs sont gérés par
PlonePAS à travers le configlet Utilisateurs et groupes. Un utilisateur peut appartenir à autant de groupes
que nécessaire, voire aucun groupe. Un groupe peut appartenir à un autre groupe (imbrication).
i18n Abréviation commune du terme “internationalisation” (il y a 18 lettres entre le “i” et le “n” de “internatonalisation”). Opération consistant à marquer le code (Python, templates, ...) pour lui permettre de fournir les
textes de l’interface utilisateur en différents langages. Voir l10n.
interface (en Python) : Une interface est une classe spéciale décrivant l’API publique de toute autre classe
l’implémentant. L’utilisation des interfaces est à la base de la ZCA.
invite de commandes Logiciel vous invitant à contrôler votre système en fournissant des commandes et en lisant
le compte-rendu des dites commandes. Jusque dans les années 80, l’invite de commandes était l’unique
moyen de contrôler un ordinateur. Sous Windows, l’invite de commandes est fournie par le logiciel cmd.exe‘
alors que sous Unix - le choix est plus vaste - le couple xterm et bash est généralement utilisé.
l10n Abréviation commune de “localisation” (il y a 10 lettres entre le “l” et le “n” de “localisation”). Opération
consistant à fournir les textes de l’interface utilisateur d’un logiciel (d’un composant Plone) dans un langage
particulier. Voir i18n.
msi installer Format de bundle d’installation du monde Windows. Les fichiers de ce type ont l’extension .msi.
multiplugin Un plugin ayant l’aptitude de remplir plusieurs rôles, donc, généralement implémentant plus d’une
interface. Un plugin pour PAS est d’ailleurs généralement un multiplugin.
part Une part est une section d’un fichier buildout contenant une variable recipe définissant le rôle de la part
dans le processus d’installation global défini par la configuration buildout. Une part n’est exécutée que si
elle est référencée dans la liste parts = ... de la section [buildout].
parts voir part.
permission Protection d’accès à un objet dont la sécurité est gérée par Zope.
permissions voir permission.
PAS Aréviation de PluggableAuthService, la base du service de gestion des utilisateurs, rôles et groupes de
Plone. Voir le chapitre Gestion des utilisateurs avec PlonePAS.
paster Couteau suisse du développeur d’applications Python. Voir http ://pythonpaste.org/index.html
PATH Variable d’environnement utilisée par votre système d’exploitation pour trouver les logiciels invoqués
par l’invite de commandes. Cette variable d’environnement est constituée d’une liste de répertoires, séparés
par : pour Unix et ; sous Windows.
224
Chapitre 21. Glossaire
Plone pour les intégrateurs, Version 1.0.0
plugin Se dit d’un composant logiciel (fonction, classe, ou objet) s’intégrant dans une infrastructure existante et
ayant une interface et un rôle pré-défini vis-à-vis de cette infrastructure (le rôle est généralement défini par
une interface), mais implémentant le rôle d’une façon qui lui est propre. Les logiciels de type “plugin” sont
légion dans le monde de Plone, et plus notamment dans le service de gestion des utilisateurs PAS. Voir le
chapitre Gestion des utilisateurs avec PlonePAS.
PMI Plone Management Interface : Ensemble des formulaires fournis par Plone et ses éventuelles extensions
permettant de gérer et paramétrer le contenu et les services.
portlet Petite boite d’interface utilisateur située dans la colonne gauche d’un portail Plone. Les conditions d’apparition et les interfaces des portlets est automatiquement calculé en fonction du contexte (droits de l’utilisateur, et emplacement de navigation). L’outil de navigation et le calendrier sont des exemples de portlets.
Dans la grande majorité des cas, les portlets ne font pas strictement partie du contenu.
policy package Un policy package est un composant pour Plone défininissant la politique éditoriale du site,
et - éventuellement - sa logique métier spécifique. un policy package a également pour rôle d’installer et
paramétrer de façon spécifique Plone et les différents composants de tierce partie ajoutés.
principal Agent du système Zope exécutant une action. Un agent dispose de permissions sur les objets Zope pour
exécuter ces actions. Dans les applications Zope ou Plone, vous ne verrez que deux types de principals :
les utilisateurs (ou membres) et les groupes.
product Package Python fournissant des fonctionnalités supplémentaires à Zope ou Plone. Les produits sont
installés le plus souvent dans $INSTANCE_HOME/Products, et plus généralement dans les répertoires
du système de fichiers désignés par la directive “products” du fichier de configuration de votre instance
Zope. L’extension de Zope et Plone par produits est un héritage des anciennes versions de Zope, facilitant
ainsi l’adaptation d’extensions Zope ou Plone conçues pour des versions antérieures. Il est en conséquence
recommandé de réaliser dorénavant des composants (voir plus haut) pour ajouter des fonctionnalités à Zope
ou Plone.
produit Traduction libre de product.
profil Traduction libre de profile.
profile (GenericSetup) : un profil désigne un lot de fichiers XML définissant le paramétrage appliqué à un site
Plone permettant l’utilisation dans le dit site des ressources d’un composant ou d’un produit. Les fichiers
d’un profil GenericSetup sont – généralement – placés dans le sous-répertoire profiles/default d’un
composant ou produit.
propertysheet En français : feuille de propriétés. Dans Plone, il y a deux types de feuilles de propriétés :
– Les feuilles de propriétés servant à conserver des propriétés globales du site, celles-ci se trouvant dans le
tool portal_properties
– Les feuilles de propriétés dynamiques associées aux utilisateurs et aux groupes.
pypi PYthon Packages Index, anciennement appellé cheeseshop, est le site dans lequel la grande majorité des packages open source Python sont mis à la disposition du public. Sa page d’accueil est
http ://pypi.python.org/pypi
pywin32 Package Python pour Windows - disponible pour les architectures 32 et 64 bits - fournissant l’accès
aux services système spécifiques à ce système d’exploitation : contrôle des services, de la base de registres,
accès COM ou DCOM aux applications, accès à Exchange et Active Directory, extensions et filtres ISAPI,
etc, etc.
recipe Peut être traduit en français par “recette”. Une recipe définit le rôle d’une part d’une configuration buildout
(exemples : installation/paramétrage d’Apache, instalation d’un client ZEO, fichier de comfiguration défini
par une template, ...). La plupart des recipes disponibles sont disponible dans le site Pypi à cette adresse.
rôle Un rôle regroupe un ensemble de permissions. Tout visiteur dispose d’un ou plusieurs rôles, soit de façon
globale, soit de façon contextuelle.
SSO Single Sign On ou Authentification unique. Agent permettant de n’effectuer qu’une seule authentification
pour accéder à plusieurs sites. Comme par exemple pour Google apps (mail, agendas, documents). Voir
http ://fr.wikipedia.org/wiki/SSO
structural folder Type de contenu permettant à un contributeur d’y inclure les contenus de son choix. A contrario, le “non structural folder” permet pas à un contributeur de structurer librement son contenu. Les composants de tierce partie Products.PloneArticle et Products.Collage fournissent des exemples
de “non structural folder”.
225
Plone pour les intégrateurs, Version 1.0.0
tool Dans un contexte CMF, donc Plone, un “tool” est un objet unique dans un site fournissant un ensemble de
services et incorporant ses propres données persistantes de configuration. Les tools se trouvent à la racine de
Plone et leurs noms sont généralement préfixés par portal_. portal_properties abrite les feuilles
de propriétés de Plone et de la plupart des composants d’extension de tierce partie. portal_catalog
indexe les contenus du site...
TTW Ou “Through The Web”. Qualifie généralement le paramétrage ou la programmation d’une application
Zope depuis des formulaires accessibles uniquemant à un administrateur ou un auteur authentifié. La ZMI
est le principal outil Zope de programmation ou de paramétrage TTW.
type de contenu Traduction libre de content type.
unified installer Bundle d’installation complète de Plone, incluant Python, Zope, Plone ainsi que tous les modules requis (PIL, elementtree, ...). L’unified installer est disponible pour Windows, Mac OSX et Linux.
viewlet Une viewlet est responsable du rendu d’un composant de page, donc de la réalisation d’un bloc - generalement - HTML. Les viewlets sont généralement assemblées par un viewlet manager.
viewlet manager Un viewlet manager permet d’assembler les viewlets. L’utilisation de viewlets et de viewlet
managers permet une disposition plus souple des composants d’une page que les classiques macros ZPT
ainsi que des performances de publication améliorées.
virtualenv
virtualenv est un outil permettant de créer des installations virtuelles de Python (presque) indépendantes du Python installé de façon globale dans votre système, de sorte que tout egg ajouté dans
une installation virtuelle ne vient pas “polluer” votre installation globale. Par extension, on appelle un
“virtualenv” tout environnement virtuel créé avec cet outil. Reportez-vous au chapitre Création d’un
environnement isolé avec virtualenv pour plus de détails. Ou bien sur la page d’accueil de virtualenv
widget Élément unitaire d’une page permettant au serveur de solliciter une information à l’utilisateur. Les widgets sont généralement assemblés dans un formulaire. Plone fournit bien évidemment tous les widgets standard du langage HTML (cases à cocher, boutons, listes déroulantes, champ de saisie de texte, ...). Ses divers
composants, notamment la bibliothèque zope.formlib, KSS et Archetypes proposent des widgets plus
évolués tel que des calendriers, éditeur WYSIWYG, arbres d’exploration, ...
workflow Outil permettant de définir les différents états d’un élément, et les transitions permettant de passer
d’un état à un autre. Pour chaque état, un sous-ensemble de permissions de cet élément fixe la limite les
différents types d’accès à celui-ci. Par exemple pour interdire la vue à un utilisateur anonyme. L’exécution
de chaque transitions est protégée de façon spécifique. Par exemple, seul un modérateur peut exécuter la
transition “publier” Dans Pone, les workflows sont définis en ZMI à l’aide de l’outil DCWorkflow. Certains
types d’éléments, comme l’image, ne sont pas associés à un workflow.
ZCA Zope Component Architecture : Ensemble de services intégrés dans Zope 3, et adaptés à Zope 2 depuis
sa version 2.9 par l’entremise de Five. La ZCA fournit les outils facilitant la collaboration entre objets et
services de natures différentes concourant à la réalisation de fonctions applicatives, tout en évitant les pièges
d’un héritage complexe de classes. Par exemple, vous disposez d’un composant (A) d’exploration AJAX
d’arbre virtuel, d’un autre composant (B) gérant un contenu pouvant être représenté de façon arborescente,
il vous suffira de fournir les adapteurs permettant d’explorer le contenu des objets fournis par B à l’aide
des widgets fournis par A. Ceci ne peut bien entendu être possible que si ces deux composants exposent les
ressources ZCA (généralement des interfaces) permettant ceci. L’utilisation de la ZCA, entamée par Plone
depuis sa version 2.5, se généralise depuis sa version 3. Plus de détails dans concepts_zope3.
zc.buildout voir buildout.
ZCML Zope Configuration Markup Language : Langage basé sur XML permettant de configurer des composants
ou produits pour Zope ou Plone dans des fichiers configure.zcml ou overrides.zcml.
zexp Format binaire d’exportation et d’importation d’un objet (et éventuel sous-objets) de la ZODB. Pour exporter ou importer un fichier au format zexp, cliquez le bouton Import/Export et suivez les instructions.
ZODB Zope Object Data Base : base de données objets native de Zope.
ZMI Zope Management Interface : Interface Web de paramétrage et contrôle d’une instance Zope, permettant
l’exploration de la ZODB.
226
Chapitre 21. Glossaire
CHAPITRE 22
Indexes et tables
– genindex
– modindex
– search
227
Plone pour les intégrateurs, Version 1.0.0
228
Chapitre 22. Indexes et tables
CHAPITRE 23
Contributeurs
–
–
–
–
Vincent Fretin
Gilles Lenfant
Thomas Desvenain
Michaël Launay
229
Plone pour les intégrateurs, Version 1.0.0
230
Chapitre 23. Contributeurs
Index
Symbols
multiplugin, 224
élément, 224
P
A
part, 224
parts, 224
PAS, 224
paster, 224
PATH, 95, 224
permission, 224
permissions, 224
plugin, 224
PMI, 225
policy package, 225
portlet, 225
principal, 225
product, 225
produit, 225
profil, 225
profile, 225
propertysheet, 225
pypi, 225
pywin32, 225
adaptateur, 223
adapter, 223
AT, 223
B
brain, 223
buildout, 223
C
C, 223
component, 223
composant, 223
configlet, 223
content type, 223
D
distribute, 223
distutils, 223
dotted name, 224
E
egg, 224
eggs, 224
G
groupe, 224
I
i18n, 224
interface, 224
invite de commandes, 224
R
rôle, 225
recipe, 225
S
SSO, 225
structural folder, 225
T
tool, 225
TTW, 226
type de contenu, 226
L
U
l10n, 224
unified installer, 226
M
V
msi installer, 224
variable d’environnement
231
Plone pour les intégrateurs, Version 1.0.0
PATH, 95
viewlet, 226
viewlet manager, 226
virtualenv, 226
W
widget, 226
workflow, 226
Z
zc.buildout, 226
ZCA, 226
ZCML, 226
zexp, 226
ZMI, 226
ZODB, 226
232
Index