English
Skip to page content Skip to main navigation

e.g. "templates" or "datastore"

# Using the webapp Framework

The CGI standard is simple, but it would be cumbersome to write all of the code that uses it by hand. Web application frameworks handle these details for you, so you can focus your development efforts on your application's features. Google App Engine supports any framework written in pure Python that speaks CGI (and any WSGI-compliant framework using a CGI adaptor), including Django, CherryPy, Pylons, and web.py. You can bundle a framework of your choosing with your application code by copying its code into your application directory.

App Engine includes a simple web application framework of its own, called `webapp`. The `webapp` framework is already installed in the App Engine environment and in the SDK, so you do not need to bundle it with your application code to use it. We will use `webapp` for the rest of this tutorial.

## Hello, webapp!

A `webapp` application has three parts:

- one or more `RequestHandler` classes that process requests and build responses
- a `WSGIApplication` instance that routes incoming requests to handlers based on the URL
- a main routine that runs the `WSGIApplication` using a CGI adaptor

Let's rewrite our friendly greeting as a `webapp` application. Edit `helloworld/helloworld.py` and replace its contents with the following:

    from google.appengine.ext import webapp
    from google.appengine.ext.webapp.util import run_wsgi_app

    class MainPage(webapp.RequestHandler):
      def get(self):
        self.response.headers['Content-Type'] = 'text/plain'
        self.response.out.write('Hello, webapp World!')

    application = webapp.WSGIApplication(
                                         [('/', MainPage)],
                                         debug=True)

    def main():
      run_wsgi_app(application)

    if __name__ == "__main__":
      main()

Reload http://localhost:8080/ in your browser to see the new version in action. (If you stopped your web server, restart it by running the command described in "Hello, World!".)

## What webapp Does

The `webapp` module is in the `google.appengine.ext` package. This module is provided in the SDK, as well as in the production runtime environment.

This code defines one request handler, `MainPage`, mapped to the root URL (`/`). When `webapp` receives an HTTP GET request to the URL `/`, it instantiates the `MainPage` class and calls the instance's `get` method. Inside the method, information about the request is available using `self.request`. Typically, the method sets properties on `self.response` to prepare the response, then exits. `webapp` sends a response based on the final state of the `MainPage` instance.

The application itself is represented by a `webapp.WSGIApplication` instance. The parameter `debug=true` passed to its constructor tells `webapp` to print stack traces to the browser output if a handler encounters an error or raises an uncaught exception. You may wish to remove this option from the final version of your application.

The function run_wsgi_app() takes a WSGIApplication instance (or another WSGI-compatible application object) and runs it in App Engine's CGI environment. `run_wsgi_app()` is similar to the WSGI-to-CGI adaptor provided by the `wsgiref` module in the Python standard library, but includes a few additional features. For example, it can automatically detect whether the application is running in the development server or on App Engine, and display errors in the browser if it is running on the development server.

We'll use a few more features of `webapp` later in this tutorial. For more information about `webapp`, see the webapp reference.

## Next...

Frameworks make web application development easier, faster and less error prone. `webapp` is just one of many such frameworks available for Python. Now that we're using a framework, let's add some features.

Continue to Using the Users Service.