web2py

Introduction

web2py^[web2py] est un framework web libre et open-source pour le développement agile et sécurisé d'applications web pilotées par base de données; il est écrit en Python^[python] et programmable en Python. web2py est un framework complet, contenant donc tous les composants nécessaires pour construire des applications web totalement fonctionnelles.

web2py est conçu pour guider le développeur web à suivre les bonnes pratiques de l'ingénierie logicielle, telles que l'utilisation du pattern Modèle Vue Contrôleur (MVC). web2py sépare la représentation des données (modèle) de la présentation des données (la vue) et également de la logique applicative et de ses flux de travail (le contrôleur). web2py fournit des librairies pour aider le développeur à dessiner, implémenter et tester chacune des trois parties séparément, et les faire fonctionner ensemble.

web2py est construit pour la sécurité. Cela signifie qu'il élimine automatiquement la plupart des problèmes qui peuvent amener à des failles de sécurité, en suivant des pratiques bien établies. Par exemple, toute entrée est validée (pour éviter les injections), toute sortie est contrôlée (pour éviter le cross-site scripting), et tout fichier uploadé est renommé (pour éviter toute attaque traverse de répertoireà. web2py fait attention aux principaux problèmes de sécurité, afin que les développeurs aient le moins de chande d'introduire des failles dans leur développement.

web2py inclut une couche d'abstraction à la base de données (Database Abstraction Layer -DAL) qui écrit les requêtes SQL^[sql-w] dynamiquement afin que vous, développeurs, n'ayez pas à le faire. Cette couche d'abstraction (DAL) sait parfaitement comment générer les requêtes SQL de manière transparente pour SQLite^[sqlite], MySQL^[mysql], PostgreSQL^[postgres], MSSQL^[mssql], FireBird^[firebird], Oracle^[oracle], IBM DB2^[db2], Informix^[informix] et Ingres^[ingresdb].

La couche d'abstraction peut également générer des appels de fonction pour le Datastore Google lorsqu'elle fonctionne sur les Google App Engine (GAE)^[gae]. De manière expérimentale, nous supportons plus de bases de données et de nouvelles sont constamment ajoutées. Veuillez vérifier le site web de web2py et la mailing list pour trouver les connecteurs les plus récents. Une fois qu'une ou plusieurs tables ont été définies, web2py génère automatiquement une interface d'aministration web complète pour accéder à la base de données et aux tables.

web2py diffère des autres frameworks web du fait que ce soit le seul à totalement adopter le paradigme Web 2.0, où le web est l'ordinateur. En fait, web2py ne nécessite aucune installation ou configuration; il fonctionne sur n'importe quelle architecture qui peut exécuter du Python (Windows, Windows CE, Mac OS X, iOS, et Unix/Linux), et le développement, le déploiement, et les phases de maintenance phases pour les applications peuvent être faites via une interface web locale ou distante. web2py fonctionne avec CPython (l'implémentation C) et PyPy (Python écrit en Python), sur les versions Python 2.5, 2.6, et 2.7.

web2py fournit un système de tickets pour les erreurs remontées. Si une erreur survient, un ticket est attribué à l'utilisateur et l'erreur est enregistrée pour l'administrateur.

web2py est open source et distribué sous la licence LGPG version 3.

Une autre fonctionnalité importante de web2py est que nous, ses développeurs, travaillons à maintenir une rétro-compatibilité pour les versions futures. Ce maintien est assuré depuis la sortie de la première release de web2py en Octobre 2007. De nouvelles fonctionnalités ont été ajoutées et des bugs ont été corrigés, mais si le programme fonctionnait avec web2py 1.0, alors ce programme fonctionnera même mieux aujourd'hui.

Trouvez ici quelques exemples de déclarations web2py qui illustrent leur pouvoir et leur simplicité. Le code suivant :

db.define_table('person', Field('name'), Field('image', 'upload'))

créé une table de base de données appelée "person" avec deux champs : "name", une chaîne de caractères ; et "image", quelque chose qui a besoin d'être uploadé (l'image actuelle dans ce cas). Si la table existe déjà mais ne correspond pas à cette définition, elle va être modifiée en conséquence.

Etant donné la table définie ci-dessus, le code suivant :

form = SQLFORM(db.person).process()

créé un formulaire d'insertion pour cette tables qui permet aux utilisateurs d'uploader les images. Cela valide également le formulaire soumis, renomme l'image envoyée de manière sécurisée, stocke l'image dans un fichier, insère l'enregistrement correspondant dans la base de données, évite une double soumission, et modifie éventuellement le formulaire lui-même en ajoutant les messages d'erreur si les données transmises par l'utilisateur ne sont pas valides.

Ce code embarque un wiki totalement fonctionnel contenant tags, recherche, nuage de tags, permissions, pièces jointes, et le support:

def index(): return auth.wiki()

Alors que le code suivant :

@auth.requires_permission('read','person')
def f(): ....

empêche les visiteurs d'accéder à la fonction f à moins que le visiteur soit un membre du groupe ayant les droits de "lecture" sur les enregistrement de la table "person". Si le visiteur n'est pas connecté, il est redirigé sur une page d'identification (fournie automatiquement par défaut par web2py).

web2Py supporte également les composants, c'est à dire les actions qui peuvent être chargées dans une vue et intéragir avec le visiteur via des requêtes Ajax sans avoir à recharger la page entière. Ceci est fait via l'assistant LOAD qui autorise un design très modulaire des applications; ce sujet est traité dans le chapitre 3 dans le contexte du wiki et un peu plus en détails dans le dernier chapitre de ce livre.

Cette 5ème édition de ce livre décrit web2py 2.4.1 et les versions suivantes.

Principes

La programmation Python respecte typiquement les principes de base suivants :

• Ne pas se répéter soi-même.
• Il ne devrait y avoir qu'une seule façon de faire les choses.
• Explicite est mieux qu'implicite.

web2py englobe totalement les deux premiers principes en forçant le développeur à utiliser les pratiques d'ingénierie logicielle du son décourageant toute répétition de code. web2py accompagne le développeur à travers quasiment toutes les tâches communes dans le développement d'application web (création et traitement des formulaires, gestion des sessions, des cookies, des erreurs, etc...)

web2py diffère des autres frameworks par rapport au troisième principe, entrant parfois en conflit avec les deux autres. En particulier, web2py n'importe pas les applications utilisateur, mais les exécute dans un contexte prédéfini. Ce contexte révèle les mots-clés Python, aussi bien que les mots-clés web2py.

Pour certains, ceci peut apparaître comme magique, mais cela ne devrait pas. Simplement, en pratique, quelques modules sont déjà importés sans que vous l'ayez fait. web2py essaie d'éviter ces caractéristiques ennuyantes des autres frameworks qui forcent le développeur à importer les mêmes modules en haut de chaque modèle et contrôleur.

web2py, en important ses propres modules, fait gagner du temps et évite des erreurs, qui plus est en respectant l'esprit du "ne te répète pas toi-même" et "il ne devrait y avoir qu'une façon de faire les choses".

Si le développeur souhaite utiliser d'autres modules Python ou des modules tiers, ces modules doivent être importés explicitement, comme dans n'importe quel autre programme Python.

Frameworks web

A son niveau le plus fondamental, une application web consiste en un ensemble de programmes (ou fonctions) qui sont exécutées lorsque l'URL correspondante est visitée. La sortie du programme est retournée au visiteur et rendue par le navigateur.

Le but des frameworks web est d'autoriser les développeurs à construire de nouvelles applications rapidement, facilement et sans erreurs. C'est faisable en fournissant les APIs et les outils qui réduisent et simplifient la quantité de code requise.

Les deux approches classiques pour le developpement d'applications web sont:

• Génération HTML^{[html-w] [html-o]} de manière programmée.
• Embarquement de code dans des pages HTML.

Le premier modèle est celui qui est suivi, par exemple, immédiatement par des scripts CGI. Le second modèle est suivi, par exemple, par PHP^[php] (où le code est en PHP, un langage similaire au C), ASP (où le code est en Visual Basic), et JSP (où le code est en Java).

Ci-dessous, un exemple de programme PHP qui retrouve les données depuis une base de données lors de son exécution, et qui retourne une page HTML affichant les enregistrement sélectionnés :

<html><body><h1>Records</h1><?
  mysql_connect(localhost,username,password);
  @mysql_select_db(database) or die( "Unable to select database");
  $query="SELECT * FROM contacts";
  $result=mysql_query($query);
  mysql_close();
  $i=0;
  while ($i < mysql_numrows($result)) {
    $name=mysql_result($result,$i,"name");
    $phone=mysql_result($result,$i,"phone");
    echo "<b>$name</b><br>Phone:$phone<br /><br /><hr /><br />";
    $i++;
  }
?></body></html>

Le problème avec cette approche est que le code est embarqué dans l'HTML, et ce même code a besoin de générer du contenu HTML additionel. Il a également besoin de générer des déclarations SQL pour requêter la base de données, et en mélangeant ces différentes couches de l'application, la lecture et la maintenance du code devient très difficile. Cette situation est d'autant plus difficile pour des applications Ajax, que la complexité augmente avec le nombre de pages (fichiers) qui constituent l'application.

Cette fonctionnalité présentée dans l'exemple ci-dessus peut être exprimée avec seulement deux lignes de code Python dans web2py :

def index():
    return HTML(BODY(H1('Records'), db().select(db.contacts.ALL)))

Dans cet exemple simple, la structure de la page HTML est représentée de manière programmée par les objets HTML, BODY, et H1; la base de données db est requêtée par la commande select; et finalement, tout est sérialisé dans l'HTML. Notons bien que db n'est pas un mot-clé mais bien une variable définie par l'utilisateur. Cette terminologie sera utilisée tout au long du document pour représenter la connection à la base de données pour éviter toute confusion.

Les frameworks web sont généralement catégorisés comme l'un des types suivants : Un framework "glue" est un framework construit en assemblant (en collant ensemble) plusieurs composants tiers. Un framework "complet" est construit en créant des composants prévus spécifiquement pour être étroitement intégrés et fonctionnels ensemble.

web2py est un framework complet. Presque tous ses composants sont construits de zéro et sont prévus pour fonctionner ensemble, mais fonctionnant aussi bien en dehors du framework web2py. Pour exemple, la couche d'abstration à la base de données (DAL) or les templates de langues peuvent être utilisés indépendamment du framework web2Py en important gluon.dal ou gluon.template dans vos propres propres applications Python. gluon est le nom du module web2py qui contient des librairies système. Quelques librairies web2py, telles que la construction pour le traitement des tables de la base de données par les formulaires, ont des dépendances avec d'autres parties de web2Py. web2py peut également fonctionner avec des librairies Python tierces, incluant d'autres templates de langue et couches d'abstrations à la base de données, mais ne seront pas aussi bien intégrés que les composants originaux.

Modèle-Vue-Contrôleur

wzb2py encourage le développeur à séparer la représentation des données (le modèle), la présentation des données (la vue) et le traitement du flux applicatif (le contrôleur). Reconsidérons l'exemple précédent et voyons comment il est possible de construire une application web2py autour. Ci-après, un exemple d'interface d'édition MVC web2py :

Le flux générique d'une requête web2py est décrit dans le diagramme suivant :

Dans le diagramme :

• Le serveur peut être intégré au serveur web we2py où bien un serveur tiers, tel qu'un serveur Apache. Le serveur prend en charge le multi-threading .
• "main" est l'application WSGI principale. Elle exécute toutes les tâches communes et englobe les application utilisateur. Il gère les cookies, les sessions, les transactions, le routage d'URL et le routage inverse, ainsi que le déploiement.

Elle peut proposer et diffuser des fichiers statiques si le serveur ne le fait pas encore.

• Les composants Modèle (Model), Vue (View) et Contrôleur (Controller) construisent l'application utilisateur.
• Plusieurs applications peuvent être hébergées sur une même instance web2py.
• Les flèches en pointillés représentent la communication avec le(s) moteur(s) de base de données. Les requêtes à la base peuvent être écrites en langage SQL pur (déconseillé) ou en utilisant la couche d'abstration à la base de données (recommandé), afin que le code de l'application web2py ne soit pas dépendant d'un moteur spécifique de base de données.
• Le répartiteur créé le lien entre les URL demandées et un appel de fonction dans le contrôleur. La sortie de la fonction peut être une chaîne de caractères ou un dictionnaire de symboles (une table de hash). Les données contenues dans le dictionnaire sont affichées par une vue. Si le visiteur demande une page HTML (comportement par défaut), le dictionnaire est rendu comme page HTML. Si le visiteur demande la même page en XML, web2py essaie de trouver une vue qui peut effectuer le rendu du dictionnaire en XML. Le développeur peut créer des vues pour effectuer des rendus dans n'importe lequel des protocoles déjà supportés (HTML, XML, JSON, RSS, CSV, et RTF) ou dans des protocoles personnalisés additionels.
• Tous les appels sont englobés dans une transaction, et n'impote quelle exception non traitée entraînera l'annulation de la transaction. Si la requête réussit, la transaction est validée.
• web2py prend également en charge les sessions et les cookies de session automatiquement, et lorsqu'une transaction est validée, la session est alors stockée, à moins qu'un autre comportement n'ait été spécifié.
• Il est possible d'enregistrer des tâches récurrentes (via cron) pour démarrer de manière programmée et/ou après l'exécution de certaines actions. Par ce moyen, il est possible de démarrer de longues tâches intensives en arrière-plan sans ralentir la navigation.

Ci-après, une application minimale et complète MVC, en trois fichiers :

"db.py" est le modèle :

db = DAL('sqlite://storage.sqlite')
db.define_table('contact',
   Field('name'),
   Field('phone'))

Une connexion à la base de données est établie (dans cet exemple, une base de données SQLite est stockée dans le fichier storage.sqlite) et une table nommée contact est définie. Si la table n'existe pas, web2Py la créé et, de manière transparente en arrière-plan, génère le code SQL approprié pour le moteur de base de données choisi et utilisé. Le développeur peut voir la requête SQL générée mais n'a pas besoin de changer le code si le système de base de données, par défaut en SQLite, est remplacé par MySQL, PostgreSQL, MSSQL, FireBird, Oracle, DB2, Informix, Interbase, Ingres ou Google App Engine (SQL et NoSQL).

Une fois la table définie et créée, web2py génère également une interface de gestion web entièrement fonctionnel pour la base de données, appelée appadmin, pour accéder à la base et à ses tables.

"default.py" est le contrôleur :

def contacts():
    grid=SQLFORM.grid(db.contact, user_signature=False)
    return locals()

Dans web2py, les URLs sont liées à des modules Python et à des appels de fonction. Dans ce cas, le contrôleur contient une fonction unique (ou "action") appelé contacts. Une action peut retourner une châine de caractères (la page web) ou un dictionnaire Python (un ensemble de paires clé:valeur) ou un ensemble de variables locales (comme dans cet exemple). Si la fonction retourne un dictionnaire, le tout est transmis à une vue avec le même nom que le nom de la fonction (ou du contrôleur), qui effectue le rendu de la page en retour. Dans cet exemple, la fonction contacts génère une grille de select/search/create/update/delete pour la table db.contact et renvoie la grille à la vue.

"default/contacts.html" est la vue:

{{extend 'layout.html'}}
<h1>Manage My Contacts</h1>
{{=grid}}

Cette vue est appelée automatiquement par web2py après que la fonction associée du contrôleur (action) ait été exécutée. Le but de cette vue est d'effectuer le rendu des variables contenues par le dictionnaire retourné (dans notre cas grid) en HTML. Le fichier de vue est écrit en HTML, mais peut embarquer du code Python délimité par les balises spéciales {{ et }}. Ceci diffère un peu du code d'exemple PHP, car le seul code embarqué dans l'HTML est le code de "couche de présentation". Le fichier "layout.html" au début de la vue est fournie par web2py et constitue la mise en page pour toutes les applications web2py. Ce fichier peut facilement être modifié ou remplacé.

Pourquoi Web2py

web2py est l'un des nombreux frameworks d'application web, mais il est devenu très persuasif grâce à de nombreuses fonctionnalités uniques. web2py était à la base développé comme un outil d'apprenrissage, avec les motivations principales suivantes :

• Facilité pour les utilisateurs à apprendre le développement côté serveur sans compromettre de fonctionnalité. Pour cette raison, web2py ne requiert aucune installation ou configuration, n'a pas de dépendences (à l'exception de la distribution du code source qui requiert Python 2.5 et ses librairies standard), et présente la plupart de ses fonctiionnalités via une interface web, incluant un Environnement de Développement Intégré avec les outils de débogage et une interface pour la base de données.
• web2py a été stable dès le premier jour grâce à une approche descendante; c'est à dire que l'API a été dessinée avant d'être implémentée. Même si de nouvelles fonctionnalités ont été ajoutées, web2py n'a jamais cessé sa rétro-compatibilité, et ne l'arrêtera pas lorsque de nouvelles fonctionnalités seront ajoutées dans le futur.
• web2py s'intéresse de manière pro-active aux plus importantes failles de sécurité qui peuvent tourmenter les applications web les plus modernes comme déterminé par OWASP^[owasp] ci-après.
• web2py est très léger. Le coeur du système (librairies), incluant la couche d'abstration à la base de données, les modèles de langues, et tous les assistants ne pèsent que 1.4MO. Le code source entier incluant les des exemples d'application et les images pèsent environ 10.4MO.
• web2py a une empreinte très petite et est très rapide. Il utilise le serveur web WSGI Rocket rocket développé par Timothy Farrell. Sa rapidité est comparable à celle obtenue grâce au module Apache mod_wsgi, et supporte SSL et IPv6.
• web2py utilise la syntaxe Python pour les modèles, les contrôleurs et les vues, mais n'importe pas les modèles et contrôleurs (comme font tous les autres frameworks) - au lieu de cela, il les exécute. Cela signifie que les applications peuvent être installées, déinstallées et modifiées sans avoir à redémarrer le serveur web (même en production), et différentes applications peuvent co-exister sans qu'il y ait d'interférence entre les modules.
• web2py utilise une couche d'abstraction à la base de données (Database Abstraction Layer - DAL) au lieu d'un d'un Mapping Objet-Relationnel (Object Relational Mapper - ORM). D'un point de vue conceptuel, ceci signifie que différentes tables de la base de données sont mappées en différentes instances d'une classe Table et non pas en différentes classes, alors que les enregistrements sont mappés en instances d'une classe Row et non en instances d'une classe de la table correspondate. D'un point de vue pratique, cela signifie que la syntaxe SQL effectue des correspondances presque une à une en syntaxe DAL, et qu'il n'y a aucune meta-classe complexe à programmer comme dans la plupart des ORM, ce qui ajouterait de la latence.

WSGI ^{[wsgi-w] [wsgi-o]} (Web Server Gateway Interface) est un standard Python en pleine croissance pour la communication entre un serveur web et les applications Python.

Ci-après, une capture d'écran de l'interface admin principale de web2py :

Sécurité

L'"Open Web Application Security Project" ^[owasp] (OWASP) est une communauté internationale libre et ouverte avec pour principal but l'amélioration de la sécurité des applications logicielles.

OWASP a listé le top 10 des problèmes de sécurité entraînant un risque pour les applications web. Cette liste est copiée ici, avec une description pour chacune sur l'impact avec web2Py :

• cross site scripting
  "Cross Site Scripting (XSS): les failles XSS apparaissent lorsqu'une application utilise des données fournies par l'utilisateur et les envoie à un navigateur web sans effectuer une première validation ou encodage du contenu. XSS permet aux attaquants d'exécuter des scripts sur le navigateur de la victime qui peuvent détourner des sessions utilisateur, dégrader des sites web, potentiellement injecter des virus, etc..." web2py, par défaut, rejette toute variable injectée dans la vue, pour éviter tout XSS.
• injection flaws
  "Les failles d'injection : ces failles, particulièrement en injection SQL, sont communes aux applications web. Une injection arrive lorsque les données fournies par l'utilisateur sont envoyées à un interpréteur comme commande ou requête. Les données de l'attaquant brouillent l'interpréteur en exécutant des commandes inattendues ou en changeand des données." web2py inclut une couche d'abstraction à la base de données rendant l'injection SQL impossible. Normalement, les déclarations SQL ne sont pas écrités par le développeur. Au lieu de cela, la requête SQL est générée dynamiquement par la couche d'abstraction à la base de données, s'assurant ainsi que toute donnée à insérer dans la base est correctement formatée.
• malicious file execution
  "Exécution de fichier malicieux : du code vulnérable à de l'inclusion de fichier distant (Remote File Inclusion - RFI) permet à un attaquant d'inclure du code et des données hostiles, résultant en des attaques dévastatrices, telle qu'une mise en péril d'un serveur entier." web2py n'autorise que les fonctions exposées à être exécutées, évitant ainsi l'exécution de fichier malicieux. Les fonctions importées ne sont jamais exposées; seules les actions sont exposées. web2py utilise un interface d'aministration web qui rend très facile le suivi de ce qui est exposé et de ce qui ne l'est pas.
• insecure object reference
  "Référence directe à un oject non sécurité : une référence directe à un objet peut survenir lorsqu'un développeur expose une référence à l'implémentation d'un objet interne, tel qu'un fichier, un répertoire, un enregistrement en base de données ou une clé, comme une URL ou un paramètre de formulaire. Les attaquants peuvent manipuler ces références pour obtenir l'accès à d'autres objets sans autorisation." web2py n'expose aucun objet interne; de plus, web2py valide toutes les URLs, évitant ainsi les attaques transverses de répertoire (directory travesal attacks). web2py fournit également un mécanisme simple pour crééer des formulaires qui valident automatiquement toutes les valeurs en entrée.
• CSRF
  "Les requêtes criminelles Cross-Site (Cross Site Request Forgery - CSRF): Une attaque CSRF force le navigateur d'une victime connectée à envoyer une requête pré-authentifiée à une application web vulnérable, forçant ainsi le navigateur de la victime à exécuter une action hostile au bénéfice de l'attaquant. CSRF peut être aussi puissant que l'application web qu'il attaque." web2py évite les CSRF aussi bien que les doubles soumissions accidentelles de formulaires en assigant un jeton aléatoire éphémère à chaque formulaire. De plus, web2py utilise un UUID pour les cookies de session.
• information leakage
  improper error handling
  "Les fuites d'information et la prise en charge d'erreurs incorrectes : Les applications peuvent non intentionnellement laisser des fuites d'information sur leur configuration, des travaux internes, ou porter atteinte à l'intimité à travers une variété de problèmes applicatifs. Les attaquants utilisent cette faiblesse pour voler des données sensibles, ou conduire à des attaques plus sérieuses." web2py inclut un système de ticket. AUcune erreur ne peut résulter en code qui serait exposé à l'utilisateur. Toutes les erreurs sont loguées et un ticket est assigné à l'utilisateur autorisant le suivi de l'erreur. Mais les erreurs et le code source impliqué ne sont uniquement accessibles que par l'administrateur.
• "Authentification cassée et gestion de session : les identifiants de compte et les jetons de session ne sont souvent pas protégés correctement. Les attaquants peuvent détourner les mots de passe, les clés ou les jetons d'authentifications pour utiliser l'identité d'autres utilisateurs." web2Py fournit un mécanisme intégré pour l'authentification administrateur, et gère les sessions indépendamment pour chaque application. L'interface d'administration force l'utilisation de cookies de session sécurisés lorsque le client n'est pas en "localhost". Pour les applications, une puissante API basée sur des contrôles d'accès par rôle (Role Base Access Control) est inclue.
• cryptographic store
  "Stockage cryptographique non sécurisé : les applications web utilisent très rarement les fonctions de cryptographie correctement pour protéger les données et les identifiants de connexion. Les attaquants utilisent des données faiblement protégées pour effectuer du vol d'identification et autres crimes, telles que les fraudes de carte de crédit." web2py utilise les algorithmes de hachage MD5 ou HMAC+SHA-512 pour protéger les mots de passe stockés. Les autres algorithmes sont également disponibles.
• secure communications
  "Communications non sécurisées : les applications échouent fréquemment pour chiffrer le trafic réseau lorsqu'il est nécessaire de protéger des communications sensibles." web2py inclut le serveur ^[ssl] Rocket WSGI incluant le support SSL activé par défaut, mais peut également utiliser Apache ou Lighttpd et le module mod_ssl pour fournir la couche de chiffrement SSL des communications.
• access restriction
  "Echec de restriction d'accès à certaines URL : La plupart du temps, une application protège uniquement les fonctionnalités sensibles en évitant l'affichage de liens ou URLs à des utilisateurs non autorisés. Les attaquants peuvent utiliser cette faiblesse pour accéder et exécuter des opérations non autorisées en accédant à ces URLs directement." web2py effectue un lien entre chaque requête URL te les modules et fonctions Python. web2py fournit un mécanisme pour déclarer quelles fonctions sont publiques et lesquelles nécessitent une authentification préalable pour autorisation. L'API de contrôle d'accès par rôle autorise les développeurs à restreindre l'accès à n'importe quelle fonction en se basant sur le login, l'appartenance à un groupe ou les permissions de groupe. Les permissions sont très granulaires et peuvent être combinées avec des filtres de base de données pour permettre, par exemple, de donner un accès à certaines tables spécifiques et/ou à des enregistrements. web2py permet également d'utiliser les URLs signées numériquement et fournit une API pour signer numériquement les callbacks Ajax.

web2py a été revu pour sa sécurité et vous pouvez trouver le résultat de cette revue en référence ^{[pythonsecurity]}.

Dans la boîte

Vous pouvez télécharger web2py depuis le site web officiel :

http://www.web2py.com

web2py est composé des éléments suivants :

• librairies: fournissent le coeur des fonctionnalités de web2py et sont accessibles de manière programmable.
• serveur web: le serveur web WSGI Rocket.
• l'application admin: utilisée pour créer, dessiner et gérer les autres applications web2py. admin fournir un Environnement de Développement Intégré (EDI) web complet pour construire des applications web2py. Il inclut également d'autres fonctionnalités, telles qu'un moteur de test et un shell web.
• les applications exemples: contiennent de la documentation et des exemples interactifs. Les exemples sont un clone du site web officiel web2py.com, et incluent la documentation epydoc.
• l'application bienvenue: le template de base pour n'importe quelle autre application. Par défaut, il inclut un menu déroulant pur CSS et un système d'authentification d'utilisateur (présenté dans le chapitre 9).

web2py est distribué en code source, et en fichiers binaires pour Microsoft Windows et Mac OS X.

La distribution du code source peut être utilisée sur n'importe quelle plateforme où Python est installé et inclut les composants ci-après mentionnés. Pour exécuter le code source, vous avez besoin de Python 2.5, 2.6 ou 2.7 pré-installé sur le système. Vous aurez également besoin d'installer l'un des moteurs de base de données supportés. Pour des tests et des applications nécessitant peu de requêtes, vous pouvez utiliser la base de données SQLite, inclue avec Python 2.7.

Les versions binaires de web2py (pour Windows et Mac OS X) incluent un interpréteur Python 2.7 et une base de données SQLite. Techniquement, ces deux composants ne font pas partie de web2py. En les incluant dans les distributions binaires, cela vous permet uniquement de démarrer web2py directement.

L'image suivante montre la structure globale de web2py :

Tout en bas, nous pouvons trouver l'interpréteur. En remontant, nous trouvons le serveur web (rocket), les librairies, et les applications. Chaque application possède son propre schéma MVC (modèles, contrôleurs, vues, modules, langages, bases de données, et fichiers statiques). Chaque application inclut son propre code d'administration de la base (appadmin). TOutes les instances web2py démarrent avec trois applications : welcome (l'application de base), admin (l'EDI web), et les exemples (copie du site web et exemples).

A propos de ce livre

Ce livre inclut les chapites suivants, suite à cette introduction :

• Le chapitre 2 est une introduction minimaliste à Python. Il suppose une connaissance des concepts de la programmation procédurale et orientée objet tels que les boucles, les conditions, les appels de fonctions et de classes, et les principales syntaxes Python. Il couvre également les exemples de modules Python qui sont utilisés à tout au long de ce livre. Si vous connaissez déjà bien Python, vous pouvez passer ce chapitre.
• Le chapitre 3montre comment démarrer web2py, parle de l'interface d'administration, et guide le lecteur à travers des exemples variés en augmentant la complexité: une application qui retourne une chaine de caractères, une application compteur, un blog, et une application complète de wiki qui autorise l'envoi d'images et de commentaires, fournit l'authentification, les autorisations, les services web et un flux RSS. En lisant ce chapitre, vous serez peut être amené à vous référer au chapitre 2 pour des syntaxes Python génériques et aux chapitres suivants pour des références plus détaillées sur les fonctions qui sont utilisées.
• Le chapitre 4 couvre plus particulièrement la structure du coeur de web2py et les librairies : le mapping d'URL, les requêtes, les réponses, les sessions, le cache, l'ordonnanceur, le cron, l'internationalisation et les flux de travail généraux.
• Le chapitre 5 est une référence pour le template de langue utilisée pour la construction des vues. Il montre comment embarquer du code Python dans du code HTML, et explique comment utilise les assistants (objets permettant la génération de code HTML).
• Le chapitre 6 couvre la couche d'abstraction à la base de données, ou DAL (Database Abstraction Layer). La syntaxe de la DAL est présentée à travers une série d'exemples.
• Le chapitre 7 couvre les formulaires, la validation de ces formulaires et leur traitement. FORM est un assistant bas-niveau pour la construction de formulaires. SQLFORM est un constructeur de formulaire haut-niveau. Dans le chapitre 7, nous verrons également des API Création/Lecture/Mise à jour/Suppression (Create/Read/Update/Delete - CRUD)
• Le chapitre 8 couvre les fonctionnalités de communication, d'envoi d'emails et de SMS.
• Le chapitre 9 couvre l'authentification, les autorisations et le mécanisme de contrôle d'accès basé sur les rôles disponible dans web2py. La configuration mail et CAPTCHA sont également présentées ici, puisqu'utilisées pour l'authentification. Dans la troisième édition de ce livre, une partie a été ajoutée pour les authentifications possibles avec l'intégration de mécanismes tiers tels que OpenID, OAuth, Google, Facebook, Linkedin, etc...
• Le chapitre 10 est au sujet de la création de services web dans web2py. Nous fournissons des exemples d'intégration avec le Google Web Toolkit via Pyjamas, et avec Adobe Flash via PyAMF.
• Le chapitre 11 est à propos de web2py et des possibilités avec jQuery. web2py est construit principalement pour de la programmation côté serveur, mais inclut jQuery, puiqu'elle s'avère être la meilleure librairie JavaScript disponible pour les effets et Ajax. Dans ce chapitre, nous discuterons donc des possibilités d'intégration de jQuery avec web2py.
• Le chapitre 12 présente les composants et plugins web2py comme une possibilité de construire des applications modulables. Nous fournissons un exemple de plugin qui implémente les principales fonctionnalités, telles que la mise en forme de diagrammes, les commentaires et les tags.
• Le chapitre 13 explique le déploiement en production d'applications web2py. Plus spécifiquement, le déploiement un serveur web LAMP est présenté (ce qui est considéré comme étant la principale alternative de déploiement). Des serveurs web alternatifs sont également présentés, ainsi que la configuration d'une base de données PostgreSQL. D'autres points sont présentés comme l'exécution en tant que service sur un environnement Microsoft Windows, et le déploiement sur certaines plateformes spécifiques incluant Google Applications Engine, Heroku, et PythonAnywhere. Dans ce chapitre, les problèmes de sécurité et s'évolutivité sont également soulevés.
• Le chapitre 14 contient une variété d'autres possibilités pour résoudre des tâches spécifiques, incluant les mises à jour, le geocoding, la pagination, l'API Twitter et bien plus encore.

Ce livre couvre uniquement les fonctionnalités de base de web2py et l'API fournie avec web2py. Ce livre ne couvre pas les appliances web2py (i.e. des applications prêtes à l'emploi).

Vous pouvez télécharger les appliances web2py depuis le site correspondant ^[appliances]. Vous pouvez trouver des sujets complémentaires discutés dans les usergroup^[usergroup]. Il y a également AlterEgo^[alterego], l'ancien blog de web2py et sa FAQ.

Ce livre a été écrit en utilisant la syntaxe markmin et automatiquement converti en HTML, LaTeX et PDF.

Support

Le principal canal de support est le usergroup^[usergroup], avec ses dizaines de posts par jour. Même si vous êtes un débutant, n'hésitez pas demander - nous serons ravis de pouvoir vous aider. Il y a également un système de suivi de bug officiel sur https://github.com/web2py/web2py/issues . Enfin, une information importante, vous pouvez obtenir du support professionnel (voir le site web pour plus de détails).

Contribute

Toute aide est vraiment appréciée. Vous pouvez aider les autres utilisateurs sur les groupes utilisateur, ou en envoyant directement des patchs sur le programme (sur le site GitHub https://github.com/web2py/web2py). Même si vous trouvez une erreur dans ce livre, ou si vous avez une amélioration à apporter, le meilleur moyen de le faire est de patcher le livre directement (sous le dossier source sur le repository à https://github.com/mdipierro/web2py-book).

Eléments de style

PEP8 ^[style] contient des bonnes pratiques de style lorsque l'on développe en Python. Vous verrez que web2py ne suit pas toujours ces règles. Ce n'est ni par oubli ni par négligence; c'est notre conviction que les utilisateurs devraient suivre ces règles et nous les y encourageons. Nous avons choisi de ne pas suivre certaines de ces règles en définissant les objects d'assistants afin de minimiser la probabilité de conflits de noms avec des objets définis par l'utilisateur.

Par exemple, la classe qui représente une <div> est appelée DIV, alors que si l'on se réfère à la référence Python, elle devrait avoir été appelée Div. Nous pensons que, pour cet exemple spécifique, utiliser une déclaration tout en majuscule "DIV", est un choix plus naturel. De plus, cette approche laisse aux programmeurs la liberté de créer une classe appelée "Div" s'ils le souhaitent. Notre syntaxe s'intègre également de manière naturelle à la notation DOM pour la plupart des navigateurs (incluant, par exemple, Firefox).

En se référant au guide de style Python, toutes les chaines de caractères majuscules devraient être utilisée pour des constantes et non pour des variables. En continuant avec notre exemple, même en considérant que DIV est une classe, c'est une classe spéciale qui ne devrait jamais être modifiée par l'utilisateur car une telle modification impacterait toutes les autres applications web2py. Par ailleurs, nous pensons qu'en qualifiant la classe DIV comme quelquechose de constant, ceci justifie totalement cette notation.

En résumé, les conventions suivantes sont respectées :

• Les assistants HTML et les validateurs sont en majuscultes pour les raisons évoquées précédemment (par exemple, DIV, A, FORM, URL).
• L'objet de traduction T est en majuscule malgré le fait que ce soit une instance de classe et non une classe. Logiquement, l'objet de traduction exécute une action similaire aux assistants HTML, et affecte une partie du rendu de la présentation. Aussi, T nécessite d'être facile à localiser dans le code et doit avoir un nom court.
• Les classes DAL suivent le guide de style Python (la première lettre uniquement en majuscule), par exemple Table, Field, Query,Row, Rows, etc...

Dans tous les autres cas, nous espérons avoir suivi, autant que possible, le Guide de Style Python (PEP8). Par exemple, toutes les instances d'objets sont en minuscules (request, response, session, cache), et toutes les classes internes sont en majuscules.

Dans tous les exemples de ce libre, les mots-clés web2py sont mis en gras, alors que les chaines de caractères et les commentaires sont mis en italique.

Licence

web2py est distribué sous licence LGPL version 3. Le texte complet de la licence est disponible en référence ^[lgpl3].

En respect de la licence LGPL, vous pouvez:

• redistribuer web2py avec vos application (en incluant les versions binaires officielles)
• mettre à disposition vos applications utilisant les librairies officielles web2py sous la licence que vous souhaitez

Cependant vous devez:

• être clair dans votre documentation en mentionnant l'utilisation de web2py dans votre application
• mettre à disposition toute modification des librairies web2py sous licence LGPLv3

The license includes the usual disclaimer:

THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

**Versions précédentes*

Les versions précédentes de web2py, 1.0.*-1.90.*, ont été mises à disposition sous la licence GPL2 avec une exception commerciale, qui pour des raisons pratiques, était très similaire à la licence courante LGPLv3.

Contenu tiers distribué avec web2py

web2py contient du contenu tiers dans le répertoire gluon/contrib et des fichiers JavaScript et CSS variés. Ces fichiers sont distribués avec web2py sous leurs licences originales, comme énoncé dans les fichiers.

Reconnaissances

web2py est développé et sous copyright de Massimo Di Pierro. La première version (1.0) a été mise en ligne en Octobre 2007. Depuis, elle a été adoptée par de nombreux utilisateurs, et certains d'entre eux ont contribué aux rapports de bugs, aux tests, au débug, aux patchs et à la relecture de ce livre.

La plupart des développeurs et des contributeurs sont, par ordre alphabétique :

Adam Bryzak, Adam Gojdas, Adrian Klaver, Alain Boulch, Alan Etkin, Alec Taylor, Alexandre Andrade, Alexey Nezhdanov, Alvaro Justen, Anand Vaidya, Anatoly Belyakov, Ander Arbelaiz, Anders Roos, Andrew Replogle, Andrew Willimott, Angelo Compagnucci, Angelo and Villas, Annet Vermeer, Anthony Bastardi, Anton Muecki, Antonio Ramos, Arun Rajeevan, Attila Csipa, Ben Goosman, Ben Reinhart, Benjamin, Bernd Rothert, Bill Ferret, Blomqvist, Boris Manojlovic, Branko Vukelic, Brent Zeiben, Brian Cottingham, Brian Harrison, Brian Meredyk, Bruno Rocha, CJ Lazell, Caleb Hattingh, Carlos Galindo, Carlos Hanson, Carsten Haese, Cedric Meyer, Charles Law, Charles Winebrinner, Chris Clark, Chris May, Chris Sanders, Christian Foster Howes, Christopher Smiga, Christopher Steel, Clavin Sim, Cliff Kachinske, Corne Dickens, Craig Younkins, Dan McGee, Dan Ragubba, Dane Wright, Danny Morgan, Daniel Gonz, Daniel Haag, Daniel Lin, Dave Stoll, David Adley, David Harrison, David Lin, David Marko, David Wagner, Denes Lengyel, Diaz Luis, Dirk Krause, Dominic Koenig, Doug Warren, Douglas Philips, Douglas Soares de Andrade, Douglas and Alan, Dustin Bensing, Elcio Ferreira, Eric Vicenti, Erwin Olario, Falko Krause, Farsheed Ashouri, Felipe Meirelles, Flavien Scheurer, Fran Boon, Francisco Gama, Fred Yanowski, Friedrich Weber, Gabriele Alberti, Gergely Kontra, Gergely Peli, Gerley Kontra, Gilson Filho, Glenn Caltech, Graham Dumpleton, Gregory Benjamin, Gustavo Di Pietro, Gyuris Szabolcs, Hamdy Abdel-Badeea, Hans C. v. Stockhausen, Hans Donner, Hans Murx, Huaiyu Wang, Ian Reinhart Geiser, Iceberg, Igor Gassko, Ismael Serratos, Jan Beilicke, Jay Kelkar, Jeff Bauer, Jesus Matrinez, Jim Karsten, Joachim Breitsprecher, Joakim Eriksson, Joe Barnhart, Joel Carrier, Joel Samuelsson, John Heenan, Jon Romero, Jonas Rundberg, Jonathan Benn, Jonathan Lundell, Jose Jachuf, Joseph Piron, Josh Goldfoot, Josh Jaques, Jose Vicente de Sousa, Jurgis Pralgauskis, Keith Yang, Kenji Hosoda, Kenneth Lundstr, Kirill Spitsin, Kyle Smith, Larry Weinberg, Limodou, Loren McGinnis, Louis DaPrato, Luca De Alfaro, Luca Zachetti, Lucas D'Avila, Madhukar R Pai, Manuele Presenti, Marc Abramowitz, Marcel Hellkamp, Marcel Leuthi, Marcello Della Longa, Margaret Greaney, Maria Mitica, Mariano Reingart, Marin Prajic, Marin Pranji, Marius van Niekerk, Mark Kirkwood, Mark Larsen, Mark Moore, Markus Gritsch, Mart Senecal, Martin Hufsky, Martin Mulone, Martin Weissenboeck, Mateusz Banach, Mathew Grabau, Mathieu Clabaut, Matt Doiron, Matthew Norris, Michael Fig, Michael Herman, Michael Howden, Michael Jursa, Michael Toomim, Michael Willis, Michele Comitini, Miguel Goncalves, Miguel Lopez, Mike Amy, Mike Dickun, Mike Ellis, Mike Pechkin, Milan Melena, Muhammet Aydin, Napoleon Moreno, Nathan Freeze, Niall Sweeny, Niccolo Polo, Nick Groenke, Nick Vargish, Nico de Groot, Nico Zanferrari, Nicolas Bruxer, Nik Klever, Olaf Ferger, Oliver Dain, Olivier Roch Vilato, Omi Chiba, Ondrej Such, Ont Rif, Oscar Benjamin, Osman Masood, Ovidio Marinho Falcao Neto, Pai, Panos Jee, Paolo Betti, Paolo Caruccio, Paolo Gasparello, Paolo Valleri, Patrick Breitenbach, Pearu Peterson, Peli Gergely, Pete Hunt, Peter Kirchner, Phyo Arkar Lwin, Pierre Thibault, Pieter Muller, Piotr Banasziewicz, Ramjee Ganti, Richard Gordon, Richard Ree, Robert Kooij, Robert Valentak, Roberto Perdomo, Robin Bhattacharyya, Roman Bataev, Ron McOuat, Ross Peoples, Ruijun Luo, Running Calm, Ryan Seto, Salomon Derossi, Sam Sheftel, Scott Roberts, Sebastian Ortiz, Sergey Podlesnyi, Sharriff Aina, Simone Bizzotto, Sriram Durbha, Sterling Hankins, Stuart Rackham, Telman Yusupov, Thadeus Burgess, Thomas Dallagnese, Tim Farrell, Tim Michelsen, Tim Richardson, Timothy Farrell, Tito Garrido, Tyrone Hattingh, Vasile Ermicioi, Vidul Nikolaev Petrov, Vidul Petrov, Vinicius Assef, Vladimir Donnikov, Vladyslav Kozlovsky, Vladyslav Kozlovskyy, Wang Huaiyu, Wen Gong, Wes James, Will Stevens, Yair Eshel, Yarko Tymciurak, Yoshiyuki Nakamura, Younghyun Jo, Zahariash.

Je suis sûr que j'oublie des personnes, et j'en suis désolé.

Je remercie particulièrement Anthony, Jonathan, Mariano, Bruno, Vladyslav, Martin, Nathan, Simone, Thadeus, Tim, Iceberg, Denes, Hans, Christian, Fran et Patrick pour leurs contributions majeures à web2py et Anthony, Alvaro, Brian, Bruno, Denes, Dane Denny, Erwin, Felipe, Graham, Jonathan, Hans, Kyle, Mark, Margaret, Michele, Nico, Richard, Roberto, Robin, Roman, Scott, Shane, Sharriff, Sriram, Sterling, Stuart, Thadeus, Wen (et les autres) pour leur relecture précise des différentes version de ce livre. Leur contribution est inestimable. Si vous trouvez des erreurs dans ce libre, elles sont exclusivement de ma faute, probablement introduite par une édition de dernière minute. Je remercie également Ryan Steffen de Wiley Custom Learning Solutions pour son aide lors de la publication de la première édition de ce livre.

web2py contient du code des auteurs suivants, que je tiens vraiment à remercier :

Guido van Rossum pour Python^[python], Peter Hunt, Richard Gordon, Timothy Farrell pour le serveur web Rocket^[rocket], Christopher Dolivet pour EditArea^[editarea], Bob Ippolito pour simplejson^[simplejson], Simon Cusack et Grant Edwards pour pyRTF^[pyrtf], Dalke Scientific Software pour pyRSS2Gen^[pyrss2gen], Mark Pilgrim pour feedparser^[feedparser], Trent Mick pour markdown2^[markdown2], Allan Saddi pour fcgi.py, Evan Martin pour le module Python memcache^[memcache], John Resig pour jQuery^[jquery]

Je remercie Helmut Epp (proviseur de DePaul University), David Miller (Doyen du College of Computing and Digital Media of DePaul University), et Estia Eichten (membre de MetaCryption LLC), pour leur confiance continue et leur support.

Enfin, je souhaite remercier ma femme, Claudia, et mon fils, Marco, pour m'avoir supporté durant les nombreuses heures que j'ai passées à développer web2py, en échangeant des emails avec des utilisateurs et collaborateurs, et en écrivant ce livre. Ce livre leur est dédié.