Chapter 1: Introdução - TODO

Introdução

web2py[web2py] é um Livre e open-source web framework escrito em Python[python] e programável em Python, para desenvolvimento ágil de aplicações web seguras baseadas em banco de dados. web2py é um framework auto contido, o que significa que ele contém todos os componentes que você precisa para desenvolver completamente aplicações web funcionais.

web2py é projetado para orientar um desenvolvedor web a seguir as boas práticas da engenharia de software, tal como a utilização do padrão Model View Controller (MVC). web2py separa a representação dos dados (the model) da apresentação dos dados (the view) e também da lógica de aplicação e do fluxo de trabalho (the controller). web2py fornece bibliotecas para ajudar a criação, implementação, e teste do projeto, cada uma dessas três partes desenvolvidas separadamente, mas trabalhando em conjunto.

web2py é construído para ser seguro. Isso significa que ele atende automaticamente muitas das questões que podem levar a vulnerabilidades de segurança, seguindo as práticas bem estabelecidas. Por exemplo, web2py valida todas as entradas (para prevenir injections), escapa todas as saídas (para previvir cross-site scripting), renomeia arquivos enviados (para prevenir ataques de atravessamento de diretórios). web2py cuida das principais questões de segurança, para que os desenvolvedores tenham menos chances de encontrar vulnerabilidades.

web2py inclui uma camada de abstração de banco de dados (DAL) que escreve código SQL[sql-w] dinamicamente para que você, o desenvolvedor, não o faça. A DAL sabe como gerar código SQL de forma transparente para SQLite[sqlite], MySQL[mysql], PostgreSQL[postgres], MSSQL[mssql], FireBird[firebird], Oracle[oracle], IBM DB2[db2], Informix[informix], Ingres[ingresdb], e MongoDB[mongodb]. A DAL também pode gerar chamadas de função para o Google Datastore quando estiver rodando no Google App Engine (GAE)[gae]. Experimentalmente suportamos mais bancos de dados e os novos são constantemente adicionados. Por favor verifique no site web2py e na lista de discussão para descobrir adaptadores mais recentes. Uma vez que uma ou mais tabelas do banco de dados estão definidos, web2py gera automaticamente uma interface de administração web-based para acessar os bancos de dados e as tabelas.

web2py diferente dos outros web frameworks in that é o único a adotar totalmente o paradigma Web 2.0, onde a web é o computador. De fato, web2py não exige instalação ou configuração; ele funciona em qualquer arquitetura que aceita Python (Unix/Linux, Windows, Windows CE, Mac OS X, e iOS), e tanto o desenvolvimento, quanto a produção, e manutenção da aplicação pode ser feita por uma interface web local ou remota. web2py é executado com CPython (a implementação em C) e PyPy (Python escrito em Python), nas versões 2.5, 2.6, e 2.7, embora "oficialmente" ele só suporta 2.5, para que possamos garantir a compatibilidade com versões anteriores para as aplicações.

web2py fornece um sistema de ticketing para eventuais erros. Se um erro ocorrer, um ticket é emitido para o usuário, e o erro é registrado para o administrador.

web2py é open source e licenciado sob a versão 3 da licença LGPL.

Outra importante característica do web2py é que nós, os desenvolvedores, desejamos manter a compatibilidade com versões anteriores. Isto é feito desde a primeira versão do web2py em outubro de 2007. Novas funcionalidades foram adicionadas e bugs foram corrigidos, mas se um programa trabalhou com web2py 1.0, esse programa vai funcionar ainda melhor hoje.

Aqui estão alguns exemplos de declarações web2py que ilustram o seu poder e simplicidade. O seguinte código:

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

cria uma tabela de banco de dados chamado "pessoa" com dois campos: "Nome", uma string, e "imagem", algo que precisa ser enviado (a imagem real). Se a tabela já existe, mas não corresponde a essa definição, é alterada de forma adequada.

Dada a tabela definida acima, o seguinte código:

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

cria um formulário de inserção para esta tabela que permite aos usuários fazer upload de imagens. também valida um formulário submetido, renomeia a imagem carregada de uma forma segura, armazena a imagem em um arquivo, insere o registro correspondente no banco de dados, previne a dupla submissão, e eventualmente, modifica o próprio formulário, adicionando mensagens de erro se os dados enviados pelo usuário não passarem na validação.

Este código incorpora um wiki totalmente funcional com as tags, pesquisa, tag cloud, permissões, anexos de mídia e suporte oEmbed:

def index(): return auth.wiki()

O código a seguir em vez disso:

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

evita que os visitantes acessem a função f a menos que o visitante é um membro de um grupo cujos membros têm permissão para ler "read" os registros da tabela pessoa "person". Se o visitante não está logado, ele é direcionado para uma página de login (fornecido por padrão pelo web2py).

web2py também suporta componentes, ou seja, ações que podem ser carregados em uma view e interagir com o visitante através de Ajax sem re-carregar a página inteira. Isto é feito através de um LOAD helper que permite um design muito modular de aplicações, que é discutida no capítulo 3, no contexto da wiki e, com algum detalhe, no último capítulo deste livro.

Princípios

Programação em Python normalmente segue esses princípios básicos:

  • Não se repita - Don't repeat yourself (DRY).
  • Deve haver apenas uma maneira de fazer as coisas.
  • Explicito é melhor que implicito.

web2py abrange totalmente os dois primeiros princípios, forçando o desenvolvedor a usar o software de boas práticas de engenharia que desestimulam a repetição de código. web2py orienta o desenvolvedor através de quase todas as tarefas comuns no desenvolvimento de aplicações web (criação e processamento de formulários, gerenciando sessões, cookies, erros, etc.)

request

web2py difere de outros frameworks no que diz respeito ao terceiro princípio, que por vezes conflita com as outras duas. Em particular, web2py não importar aplicativos do usuário, mas executa-los em um contexto pré-definido. This context exposes the Python keywords, as well as the web2py keywords.

Para alguns isso pode parecer mágica, mas não deveria. Simplesmente, na prática, alguns módulos já estão importados sem ter que fazer isso. web2py está tentando evitar a característica irritante de outros frameworks que forçam o desenvolvedor para importar os mesmos módulos no topo de cada modelo e controlador.

web2py, através da importação de seus próprios módulos, economiza tempo e evita erros, seguindo, assim, o espírito de "não repetir-se" e " deve haver apenas uma forma de fazer as coisas".

Se o desenvolvedor deseja usar outros módulos Python ou módulos de terceiros, os módulos devem ser importados explicitamente, como em qualquer outro programa Python.

Web frameworks

PHP
ASP
JSP

Em seu nível mais fundamental, uma aplicação web é composto de um conjunto de programas (ou funções) que são executadas quando o URL correspondente é visitado. A saída do programa é retornada para o visitante e transmitido pelo browser.

O objetivo de frameworks web é permitir que desenvolvedores criem novos aplicativos de forma rápida, fácil e sem erros. Isso é feito por fornecimento de APIs e ferramentas que reduzem e simplificam a quantidade de codificação que é necessária.

As duas abordagens clássicas para o desenvolvimento de aplicações web são:

  • Geração de HTML[html-w] [html-o] programaticamente.
  • Incorporação de código em páginas HTML.

O primeiro modelo é o que foi seguido, por exemplo, pelos primeiros scripts CGI. O segundo modelo é seguido, por exemplo por, PHP php : citar (onde o código é em PHP, uma linguagem C-like), ASP (onde o código é em Visual Basic), e JSP (onde o código é em Java).

Aqui é um exemplo de um programa para que, quando executado, recupera dados de um banco de dados e retorna uma página HTML que mostra os registros selecionados:

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

O problema com esta abordagem é que o código está incorporado em HTML, mas o mesmo código também precisa gerar HTML adicional e gerar instruções SQL para consultar o banco de dados, emaranhando várias camadas dea aplicação e tornando difícil de ler e manter. A situação é ainda pior para aplicações Ajax , e a complexidade cresce com o número de páginas (arquivos) que compõem a aplicação.

A funcionalidade do exemplo acima pode ser expressa em web2py com duas linhas de código Python:

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

Neste exemplo simples, a estrutura da página HTML é representada programaticamente a HTML, CORPO e H1 objetos. O banco de dados db é consultado pelo comando select, finalmente, tudo é serializado em HTML. Note que db não é uma palavra, mas uma variável definida pelo usuário. Vamos usar esse nome consistentemente para se referir a uma conexão de banco de dados para evitar confusão.

Frameworks web são geralmente classificados como um dos dois tipos: Um framework "glued" é construído pela montagem (colando) diversos componentes de terceiros. Um framework "full-stack" é construído através da criação de componentes projetados especificamente para serem totalmente integrados e trabalharem juntos.

web2py é um framework full-stack. Quase todos os seus componentes são construídos a partir do zero e são projetados para trabalhar juntos, mas eles funcionam igualmente bem fora da estrutura completa web2py. Por exemplo, a camada de abstração de banco de dados (DAL) ou a linguagem de template podem ser usados independente do web2py framework,importando gluon.dal ou gluon.template em seus próprios aplicativos Python. gluon é o nome do módulo que contém o web2py bibliotecas do sistema. Algumas bibliotecas web2py, como a construção e processamento de formulários a partir de tabelas de banco de dados, tem dependências em outras partes do web2py. web2py também pode trabalhar com bibliotecas Python de terceiros, incluindo outras linguagens de template e Dals, mas eles não serão tão bem integrados como os componentes originais.

Model-View-Controller

Model-View-Controller

web2py incentiva o desenvolvedor a representação de dados em separado (model), os dados apresentação (view) e o fluxo de trabalho do aplicativo (controller). Vamos considerar novamente o exemplo anterior e veja como construir uma aplicação web2py em torno dele. Aqui está um exemplo da interface de edição MVC web2py:

image

O fluxo de trabalho típico de um request web2py é descrito no diagrama seguinte:

image

No diagrama:

  • O servidor pode ser o servidor web embutido no web2py ou um servidor de terceiros, como o Apache. O servidor lida com multi-threading.
  • "main" é a principal aplicação WSGI. Ele executa todas as tarefas comuns e envolve aplicativos do usuário. Trata-se de cookies, sessões, transações, encaminhamento e roteamento de URL, e expedição reversa.

Ela pode servir e transmitir arquivos estáticos se o servidor web já não está fazendo isso.

  • Os componentes Models, Views e Controller compõe a aplicação do usuário.
  • Múltiplas aplicações podem ser hospedadas na mesma instância de web2py.
  • As setas a tracejado representam a comunicação com o(s) mecanismo(s) de banco de dados. As consultas de banco de dados podem ser escritos em SQL puro (desencorajado) ou usando o web2py camada de abstração de banco de dados (recomendado), de modo que o código do aplicativo web2py não é dependente do mecanismo banco de dados específico.
  • O dispatcher mapeia a URL solicitada para uma chamada de função no controller. A saída da função pode ser uma string ou um dicionário de símbolos (uma tabela hash). Os dados do dicionário são renderizados por uma view. Se o visitante solicita uma página HTML (o padrão), o dicionário é renderizado em uma página HTML. Se o visitante solicita a mesma página em XML, web2py tenta encontrar uma visão que pode renderizar o dicionário em XML. O desenvolvedor pode criar visões para processar páginas em qualquer um dos protocolos já suportados (HTML, XML, JSON, RSS, CSV e RTF) ou em protocolos personalizados adicionais.
  • Todas as chamadas são envolvidas em uma transação, e qualquer exceção não tratada faz com que a transação seja revertida. Se o pedido for bem sucedida, a transação é confirmada.
  • web2py também lida com sessões e cookies de sessão automaticamente, e quando a transação for confirmada, a sessão também é armazenada, a menos que especificado o contrário.
  • É possível registrar tarefas recorrentes (via cron) para ser executado em horários programados e / ou após a conclusão de determinadas ações. Desta forma é possível realizar tarefas longas e intensas em segundo plano sem reduzir a velocidade da navegação.

Aqui esta um aplicativo MVC mínimo e completo, que consiste em três arquivos:

"db.py" este é o model:

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

Ele se conecta ao banco de dados (Neste exemplo uma SQLite database armazenada no arquivo storage.sqlite) e define uma tabela chamada contact. Se a tablela não existe, web2py irá cria-la, transparentimente e em plano de fundo, gerar código SQL no dialeto SQL específico para o mecanismo de base de dados usado. O desenvolvedor pode o ver o código SQL gerado, mas não precisa alterar o código se o back-end de banco de dados, cujo padrão é SQLite, for substituído por MySQL, PostgreSQL, MSSQL, FireBird, Oracle, DB2, Informix, Interbase, Ingres, e Google App Engine (SQL e NoSQL).

Uma vez que a tabela é definida e criada, web2py também gera uma interface totalmente funcional baseada na Web de administração de banco de dados, chamada ** AppAdmin , para acessar o banco de dados e as tabelas.

"default.py" este é o controller:

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

Em web2py, URLs são mapeadas para módulos Python e chamadas de função. Neste caso, o controller contem uma única função (ou "action") chamada contacts. Uma action pode retornar uma string (a página da web) ou um dicionário Python (um conjunto de pares key:value ) ou um conjunto de variáveis locais (como no exemplo). Se a função retornar um dicionário, ele é passado para a view com o mesmo nome do controller / função, que por sua vez processa a página. Nesse exemplo, a função contacts gera uma grid que permite select/search/create/update/delete na tabela db.contact e retorna esse grid para a view.

"default/contacts.html" esta é a view:**

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

Esta view é chamado automaticamente pelo web2py após a função de controller associada (ação) é executado. O objetivo dessa view é renderizar as variáveis ​​no dicionário retornado (no nosso caso grid) em HTML. O arquivo de view é escrito em HTML, mas ele incorpora código Python delimitado por {{ e }}. Isto é muito diferente do exemplo do código de PHP, porque o único código embutido no HTML é o código da "camada de apresentação". O arquivo "layout.html" referenciado no topo da view é fornecido pelo web2py e constitui o layout básico para todas as aplicações web2py. O arquivo de layout pode facilmente ser modificado ou substituído.

Por que web2py?

web2py é um dos muitos frameworks de desenvolvimento web, mas tem recursos interessantes e únicos. web2py foi originalmente desenvolvido como uma ferramenta de ensino, com as seguintes motivações primárias:

  • Fácil para os usuários que estão aprendendo desenvolvimento web server-side sem comprometer funcionalidades. Por essa razão web2py não necessita de instalação ou configuração, não possui dependências (exceto pelo próprio código fonte , que requer Python 2.5 e seus módulos da biblioteca padrão), e expõe a maior parte de sua funcionalidade através de uma interface Web, incluindo um ambiente de desenvolvimento integrado com Debugger e interface de banco de dados.
  • web2py tem se mantido estável desde o primeiro dia, pois segue um projeto top-down; i.e., ou seja, a sua API foi projetada antes de ser implementada. Mesmo depois de novas funcionalidades serem adicionadas, web2py nunca quebrou a compatibilidade, e não vai quebrar a compatibilidade quando uma funcionalidade adicional for adicionada no futuro.
  • web2py proativamente aborda as questões de segurança mais importantes que afligem muitas aplicações web modernas,conforme determinado pelo OWASP[owasp].
  • web2py é leve. Suas bibliotecas centrais, incluindo a camada de abstração de banco de dados, a linguagem de template, e toda a quantidade de helpers tem apenas 1.4MB. O código-fonte inteiro, incluindo aplicações de exemplo e imagens equivale a 10,4 MB.
  • web2py ocupa pouco espaço e é muito rápido. Ele usa o Rocket[rocket] Servidor web WSGI desenvolvido por Timothy Farrell. Ele é tão rápido quanto o Apache com mod_wsgi, e suporta SSL e IPv6.
  • web2py utiliza sintaxe Python para models, controllers e views, mas não importa models e controllers (como todos os outros frameworks Python fazem) - em vez disso os executa. Isso significa que os aplicativos podem ser instalados, desinstalados, e modificado sem a necessidade de reiniciar o servidor web (mesmo em produção), e os diferentes aplicativos podem coexistir sem seus módulos interferindo uns com os outros.
  • web2py usa a Database Abstraction Layer (DAL) ao em vez da Object Relational Mapper (ORM). Do ponto de vista conceitual, isso significa que as diferentes tabelas de banco de dados são mapeados em diferentes instâncias de uma classe Table e não em diferentes classes, enquanto que os registros são mapeados em instâncias de uma classe Row, não em instâncias da classe tabela correspondente. De um ponto de vista prático, significa que a sintaxe SQL é mapeada quase em um-para-um na sintaxe DAL, e não há nenhuma programação metaclass complexa acontecendo sob o capô como nos ORMs populares, que gostaria de acrescentar latência.

WSGI [wsgi-w] [wsgi-o] (Web Server Gateway Interface) é um padrão de Python criado para a comunicação entre um servidor web e aplicações Python.

Aqui está uma imagem da interface principal do web2py admin:

image

Segurança

security

O Open Web Application Security Project[owasp] (OWASP) é uma comunidade mundial livre e de código aberto focado em melhorar a segurança de aplicações de software.

OWASP listou os dez principais problemas de segurança que colocam aplicações web em risco. Essa lista é reproduzida aqui, junto com uma descrição de como cada questão é abordada por web2py:

  • cross site scripting
    "Cross Site Scripting (XSS): falhas XSS ocorrem sempre que uma aplicação obtém os dados fornecidos pelo usuário e os envia para um navegador web sem primeiro validar ou codificar esse conteúdo. XSS permite que atacantes executar scripts no navegador da vítima, que pode sequestrar sessões de usuários, desfigurar sites, possivelmente introduzir worms, etc." web2py, por padrão, escapa todas as variáveis renderizadas na view, prevenindo XSS.
  • injection flaws
    "Injection Flaws: Injection flaws, injeções de SQL particularmente, são comuns em aplicações web. Injections ocorre quando os dados fornecidos pelo usuário são enviados para um intérprete, como parte de um comando ou consulta. O atacante usa truques hostis para o intérprete executar comandos indesejados ou alterar dados." web2py inclui uma camada de abstração de banco de dados que torna a injeção de SQL impossível. Normalmente, as instruções SQL não são escritas pelo desenvolvedor. Em vez disso, SQL é gerado dinamicamente pelo DAL, garantindo que todos os dados inseridos estão devidamente escapados.
  • malicious file execution
    "Malicious File Execution: Código vulnerável à inclusão de arquivos remotos (RFI) permite a atacantes incluir dados e código hostil, resultando em ataques devastadores, como comprometer servidores totalmente." web2py permite apenas funções expostas a serem executados, impedindo a execução de arquivos maliciosos. Funções importadas nunca são expostas, apenas ações estão expostas. web2py utiliza uma interface de administração baseada na Web que torna muito fácil acompanhar o que está exposto e o que não está.
  • insecure object reference
    "Insecure Direct Object Reference: A referência direta à objeto ocorre quando um desenvolvedor expõe uma referência a um objeto de implementação interna, como um arquivo, diretório, registro de dados, ou chave, como um parâmetro de URL ou formulário. Os atacantes podem manipular estas referências para acessar outros objetos sem autorização." web2py não expõe quaisquer objetos internos; Além disso, web2py valida todas as URLs, evitando assim ataques de atravessamento de diretórios. web2py também fornece um mecanismo simples para criar formulários que validam automaticamente todos os valores de entrada.
  • CSRF
    "Cross Site Request Forgery (CSRF): Um ataque CSRF força a iniciar sessão no navegador da vítima para enviar um pedido de pré-autenticação para uma aplicação web vulnerável, o que, em seguida, força o navegador da vítima a executar uma ação maliciosa em prol do atacante. CSRF pode ser tão poderoso quanto a aplicação Web que ele ataca." web2py evita CSRF, bem como acidental duplo envio de formulários através da atribuição de um sinal aleatório de uma só vez a cada formulário. Além disso web2py utiliza o UUID para o cookie de sessão.
  • information leakage
    improper error handling
    "Information Leakage e Improper Error Handling: Os aplicativos podem não intencionalmente vazar informações sobre sua configuração, funcionamento interno, ou violar a privacidade através de uma variedade de problemas de aplicação. Os atacantes se aproveitam dessa fraqueza para roubar dados sensíveis ou conduzir ataques mais graves." web2py inclui um sistema de bilhetagem. Nenhum erro pode resultar em exibição de código para os usuários. Todos os erros são registrados e um ticket, que permite o rastreamento de erro, é emitido para o usuário. Mas os erros e o código fonte só podem ser acessados pelo administrador.
  • "Broken Authentication and Session Management: Credenciais da conta e tokens de sessão muitas vezes não são devidamente protegidos. Atacantes comprometem senhas, chaves ou tokens de autenticação para assumir a identidade de outros usuários." web2py fornece um mecanismo built-in para autenticação de administrador e gere sessões de forma independente para cada aplicação. A interface administrativa também obriga o uso de cookies de sessão seguro quando o cliente não é "localhost". Para aplicações, ele inclui uma poderosa API de controle de acesso.
  • cryptographic store
    "Insecure Cryptographic Storage: Aplicações Web raramente utilizam funções criptográficas de forma adequada para proteger os dados e credenciais. Os invasores usam dados protegidos fracamente para realizar o roubo de identidade e outros crimes como fraude de cartão de crédito." web2py utiliza o MD5 ou o HMAC + algoritmos de hash SHA-512 para proteger as senhas armazenadas. Outros algoritmos também estão disponíveis.
  • secure communications
    "Insecure Communications: Aplicações freqüentemente falham em criptografar tráfego de rede quando for necessário para proteger as comunicações sensíveis." web2py inclui o servidor Rocket WSGI que é SSL-enabled[ssl], mas também pode usar o Apache ou Lighttpd e mod_ssl para fornecer criptografia SSL de comunicações.
  • access restriction
    "Failure to Restrict URL Access: Frequentemente uma aplicação só protege funcionalidade sensível ao impedir a exibição de links ou URLs para usuários não autorizados. Os atacantes podem usar esta fragilidade para acessar e realizar operações não autorizadas, acessando as URLs diretamente." web2py mapeia URL request para módulos Python e funções. web2py fornece um mecanismo para declarar quais as funções são públicas e quais exigem autenticação e autorização. A Role Based Access Control API incluída permite aos desenvolvedores restringir o acesso a qualquer função com base no login, membros do grupo ou o grupo de permissões baseadas. As permissões são muito granulares e podem ser combinadas com filtros de dados para permitir, por exemplo, acesso a tabelas específicos e / ou registos. web2py também permite URL assinado digitalmente e fornece API para assinar digitalmente os retornos de chamada do Ajax.

web2py foi revisado para a segurança e você pode encontrar o resultado da análise em ref.[pythonsecurity].

In the box

You can download web2py from the official web site:

http://www.web2py.com

web2py is composed of the following components:

  • libraries: provide core functionality of web2py and are accessible programmatically.
  • web server: the Rocket WSGI web server.
  • the admin application: used to create, design, and manage other web2py applications. admin provides a complete web-based Integrated Development Environment (IDE) for building web2py applications. It also includes other functionality, such as web-based testing and a web-based shell.
  • the examples application: contains documentation and interactive examples. examples is a clone of the official web2py.com web site, and includes epydoc documentation.
  • the welcome application: the basic scaffolding template for any other application. By default it includes a pure CSS cascading menu and user authentication (discussed in Chapter 9).

web2py is distributed in source code, and in binary form for Microsoft Windows and for Mac OS X.

The source code distribution can be used in any platform where Python runs and includes the above-mentioned components. To run the source code, you need Python 2.5 pre-installed on the system. You also need one of the supported database engines installed. For testing and light-demand applications, you can use the SQLite database, included with Python 2.5.

The binary versions of web2py (for Windows and Mac OS X) include a Python 2.5 interpreter and the SQLite database. Technically, these two are not components of web2py. Including them in the binary distributions enables you to run web2py out of the box.

The following image depicts the overall web2py structure:

image

About this book

This book includes the following chapters, besides this introduction:

  • Chapter 2 is a minimalist introduction to Python. It assumes knowledge of both procedural and object-oriented programming concepts such as loops, conditions, function calls and classes, and covers basic Python syntax. It also covers examples of Python modules that are used throughout the book. If you already know Python, you may skip Chapter 2.
  • Chapter 3 shows how to start web2py, discusses the administrative interface, and guides the reader through various examples of increasing complexity: an application that returns a string, a counter application, an image blog, and a full blown wiki application that allows image uploads and comments, provides authentication, authorization, web services and an RSS feed. While reading this chapter, you may need to refer to Chapter 2 for general Python syntax and to the following chapters for a more detailed reference about the functions that are used.
  • Chapter 4 covers more systematically the core structure and libraries: URL mapping, request, response, sessions, caching, cron, internationalization and general workflow.
  • Chapter 5 is a reference for the template language used to build views. It shows how to embed Python code into HTML, and demonstrates the use of helpers (objects that can generate HTML).
  • Chapter 6 covers the Database Abstraction Layer, or DAL. The syntax of the DAL is presented through a series of examples.
  • Chapter 7 covers forms, form validation and form processing. FORM is the low level helper for form building. SQLFORM is the high level form builder. In Chapter 7 we also discuss legacy Create/Read/Update/Delete (CRUD) API.
  • Chapter 8 covers communication with as sending emails and SMSes.
  • Chapter 9 covers authentication, authorization and the extensible Role-Based Access Control mechanism available in web2py. Mail configuration and CAPTCHA are also discussed here, since they are used for authentication. In the third edition of the book we have added extensive coverage of integration with third-party authentication mechanisms such as OpenID, OAuth, Google, Facebook, LinkedIn, etc.
  • Chapter 10 is about creating web services in web2py. We provide examples of integration with the Google Web Toolkit via Pyjamas, and with Adobe Flash via PyAMF.
  • Chapter 11 is about web2py and jQuery recipes. web2py is designed mainly for server-side programming, but it includes jQuery, since we have found it to be the best open-source JavaScript library available for effects and Ajax. In this chapter, we discuss how to effectively use jQuery with web2py.
  • Chapter 12 discusses web2py components and plugins as a way to build modular applications. We provide an example of a plugin that implements many commonly used functionality, such as charting, comments, tagging, and wiki.
  • Chapter 13 is about production deployment of web2py applications. We mainly address three possible production scenarios: on a Linux web server or a set of servers (which we consider the main deployment alternative), running as a service on a Microsoft Windows environment, and deployment on the Google Applications Engine. In this chapter, we also discuss security and scalability issues.
  • Chapter 14 contains a variety of other recipes to solve specific tasks, including upgrades, geocoding, pagination, the Twitter API, and more.

This book only covers basic web2py functionalities and the API that ships with web2py. This book does not cover web2py appliances (i.e. ready made applications).

You can download web2py appliances from the corresponding web site [appliances].

You can find additional topics discussed on the usergroup[usergroup]. There is also AlterEgo[alterego], the old web2py blog and FAQ.

MARKMIN

This book has been written using the markmin syntax and automatically converted to HTML, LaTeX and PDF.

Support

The main support channel is the usergroup[usergroup], with dozens of posts every day. Even if you're a newbie, don't hesitate to ask - we'll be pleased to help you. There is also a formal issue tracker system on http://code.google.com/p/web2py/issue . Last but not least, you can have professional support (see the web site for details).

Contribute

Any help is really appreciated. You can help other users on the user group, or by directly submitting patches on the program (at the GitHub site https://github.com/web2py/web2py). Even if you find a typo on this book, or have an improvement on it, the best way to help is by patching the book itself (which is under the source folder of the repository at https://github.com/mdipierro/web2py-book).

Elements of style

PEP8 [style] contains good style practices when programming with Python. You will find that web2py does not always follow these rules. This is not because of omissions or negligence; it is our belief that the users of web2py should follow these rules and we encourage it. We chose not to follow some of those rules when defining web2py helper objects in order to minimize the probability of name conflict with objects defined by the user.

For example, the class that represents a <div> is called DIV, while according to the Python style reference it should have been called Div. We believe that, for this specific example that using an all-upper-case "DIV" is a more natural choice. Moreover, this approach leaves programmers free to create a class called "Div" if they choose to do so. Our syntax also maps naturally into the DOM notation of most browsers (including, for example, Firefox).

According to the Python style guide, all-upper-case strings should be used for constants and not variables. Continuing with our example, even considering that DIV is a class, it is a special class that should never be modified by the user because doing so would break other web2py applications. Hence, we believe this qualifies the DIV class as something that should be treated as a constant, further justifying our choice of notation.

In summary, the following conventions are followed:

  • HTML helpers and validators are all upper case for the reasons discussed above (for example DIV, A, FORM, URL).
  • The translator object T is upper case despite the fact that it is an instance of a class and not a class itself. Logically the translator object performs an action similar to the HTML helpers, it affects rendering part of the presentation. Also, T needs to be easy to locate in the code and must have a short name.
  • DAL classes follow the Python style guide (first letter capitalized), for example Table, Field, Query, Row, Rows, etc.

In all other cases we believe we have followed, as much as possible, the Python Style Guide (PEP8). For example all instance objects are lower-case (request, response, session, cache), and all internal classes are capitalized.

In all the examples of this book, web2py keywords are shown in bold, while strings and comments are shown in italic.

License

license

web2py is licensed under the LGPL version 3 License. The full text of the license if available in ref.[lgpl3].

In accordance with LGPL you may:

  • redistribute web2py with your apps (including official web2py binary versions)
  • release your applications which use official web2py libraries under any license you wish

Yet you must:

  • make clear in the documentation that your application uses web2py
  • release any modification of the web2py libraries under the LGPLv3 license

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.

Earlier versions

Earlier versions of web2py, 1.0.*-1.90.*, were released under the GPL2 license plus a commercial exception which, for practical purposes, was very similar to the current LPGLv3.

Third party software distributed with web2py

web2py contains third party software under the gluon/contrib/ folder and various JavaScript and CSS files. These files are distributed with web2py under their original licenses, as stated in the files.

Acknowledgments

web2py was originally developed by and copyrighted by Massimo Di Pierro. The first version (1.0) was released in October, 2007. Since then it has been adopted by many users, some of whom have also contributed bug reports, testing, debugging, patches, and proofreading of this book.

Some of the major developers and contributors are, in alphabetical order by first name:

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, José 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'Ávila, 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, 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.

I am sure I forgot somebody, so I apologize.

I particularly thank Anthony, Jonathan, Mariano, Bruno, Vladyslav, Martin, Nathan, Simone, Thadeus, Tim, Iceberg, Denes, Hans, Christian, Fran and Patrick for their major contributions to web2py and 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 (and others) for proofreading various versions of this book. Their contribution was invaluable. If you find any errors in this book, they are exclusively my fault, probably introduced by a last-minute edit. I also thank Ryan Steffen of Wiley Custom Learning Solutions for help with publishing the first edition of this book.

web2py contains code from the following authors, whom I would like to thank:

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

I thank Helmut Epp (provost of DePaul University), David Miller (Dean of the College of Computing and Digital Media of DePaul University), and Estia Eichten (Member of MetaCryption LLC), for their continuous trust and support.

Finally, I wish to thank my wife, Claudia, and my son, Marco, for putting up with me during the many hours I have spent developing web2py, exchanging emails with users and collaborators, and writing this book. This book is dedicated to them.

 top