google/appengine/ext/webapp/util.py

#!/usr/bin/env python
#
# Copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#




"""Convience functions for the Webapp framework."""










__all__ = ['login_required',
           'run_wsgi_app',
           'add_wsgi_middleware',
           'run_bare_wsgi_app',
           ]

import os
import sys
import wsgiref.util

from google.appengine.api import users
from google.appengine.ext import webapp


def login_required(handler_method):
  """A decorator to require that a user be logged in to access a handler.

  To use it, decorate your get() method like this:

    @login_required
    def get(self):
      user = users.get_current_user(self)
      self.response.out.write('Hello, ' + user.nickname())

  We will redirect to a login page if the user is not logged in. We always
  redirect to the request URI, and Google Accounts only redirects back as a GET
  request, so this should not be used for POSTs.
  """
  def check_login(self, *args):
    if self.request.method != 'GET':
      raise webapp.Error('The check_login decorator can only be used for GET '
                         'requests')
    user = users.get_current_user()
    if not user:
      self.redirect(users.create_login_url(self.request.uri))
      return
    else:
      handler_method(self, *args)
  return check_login


def run_wsgi_app(application):
  """Runs your WSGI-compliant application object in a CGI environment.

  Compared to wsgiref.handlers.CGIHandler().run(application), this
  function takes some shortcuts.  Those are possible because the
  app server makes stronger promises than the CGI standard.

  Also, this function may wrap custom WSGI middleware around the
  application.  (You can use run_bare_wsgi_app() to run an application
  without adding WSGI middleware, and add_wsgi_middleware() to wrap
  the configured WSGI middleware around an application without running
  it.  This function is merely a convenient combination of the latter
  two.)

  To configure custom WSGI middleware, define a function
  webapp_add_wsgi_middleware(app) to your appengine_config.py file in
  your application root directory:

    def webapp_add_wsgi_middleware(app):
      app = MiddleWareClassOne(app)
      app = MiddleWareClassTwo(app)
      return app

  You must import the middleware classes elsewhere in the file.  If
  the function is not found, no WSGI middleware is added.
  """
  run_bare_wsgi_app(add_wsgi_middleware(application))


def add_wsgi_middleware(application):
  """Wrap WSGI middleware around a WSGI application object."""
  return webapp._config_handle.add_wsgi_middleware(application)


def run_bare_wsgi_app(application):
  """Like run_wsgi_app() but doesn't add WSGI middleware."""
  env = dict(os.environ)
  env["wsgi.input"] = sys.stdin
  env["wsgi.errors"] = sys.stderr
  env["wsgi.version"] = (1, 0)
  env["wsgi.run_once"] = True
  env["wsgi.url_scheme"] = wsgiref.util.guess_scheme(env)
  env["wsgi.multithread"] = False
  env["wsgi.multiprocess"] = False
  result = application(env, _start_response)
  try:
    if result is not None:
      for data in result:
        sys.stdout.write(data)
  finally:
    if hasattr(result, 'close'):
      result.close()


def _start_response(status, headers, exc_info=None):
  """A start_response() callable as specified by PEP 333"""
  if exc_info is not None:

    raise exc_info[0], exc_info[1], exc_info[2]
  print "Status: %s" % status
  for name, val in headers:
    print "%s: %s" % (name, val)
  print
  return sys.stdout.write