initial appengine setup; BROKEN

1 files changed, 528 insertions, 0 deletions

diff --git a/appengine_django/__init__.py b/appengine_django/__init__.py
new file mode 100644
index 0000000..629695d
--- /dev/null
+++ b/appengine_django/__init__.py
@@ -0,0 +1,528 @@
+#!/usr/bin/python2.5
+#
+# Copyright 2008 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.
+
+"""Support for integrating a Django project with the appengine infrastructure.
+
+This requires Django 1.0beta1 or greater.
+
+This module enables you to use the Django manage.py utility and *some* of it's
+subcommands. View the help of manage.py for exact details.
+
+Additionally this module takes care of initialising the datastore (and a test
+datastore) so that the Django test infrastructure can be used for your
+appengine project.
+
+To use this module add the following two lines to your main.py and manage.py
+scripts at the end of your imports:
+  from appengine_django import InstallAppengineHelperForDjango
+  InstallAppengineHelperForDjango()
+
+If you would like to use a version of Django other than that provided by the
+system all you need to do is include it in a directory just above this helper,
+eg:
+  appengine_django/__init__.py        -  This file
+  django/...                          - your private copy of Django.
+"""
+
+import logging
+import os
+import re
+import sys
+import unittest
+import zipfile
+
+
+DIR_PATH = os.path.abspath(os.path.dirname(__file__))
+PARENT_DIR = os.path.dirname(DIR_PATH)
+if PARENT_DIR.endswith(".zip"):
+  # Check for appengine_django itself being in a zipfile.
+  PARENT_DIR = os.path.dirname(PARENT_DIR)
+
+# Add this project to the start of sys path to enable direct imports.
+sys.path = [PARENT_DIR,] + sys.path
+
+# Try to import the appengine code from the system path.
+try:
+  from google.appengine.api import apiproxy_stub_map
+except ImportError, e:
+  # Not on the system path. Build a list of alternative paths where it may be.
+  # First look within the project for a local copy, then look for where the Mac
+  # OS SDK installs it.
+  paths = [os.path.join(PARENT_DIR, '.google_appengine'),
+           os.path.join(PARENT_DIR, 'google_appengine'),
+           '/usr/local/google_appengine']
+  # Then if on windows, look for where the Windows SDK installed it.
+  for path in os.environ.get('PATH', '').split(';'):
+    path = path.rstrip('\\')
+    if path.endswith('google_appengine'):
+      paths.append(path)
+  try:
+    from win32com.shell import shell
+    from win32com.shell import shellcon
+    id_list = shell.SHGetSpecialFolderLocation(
+        0, shellcon.CSIDL_PROGRAM_FILES)
+    program_files = shell.SHGetPathFromIDList(id_list)
+    paths.append(os.path.join(program_files, 'Google',
+                              'google_appengine'))
+  except ImportError, e:
+    # Not windows.
+    pass
+  # Loop through all possible paths and look for the SDK dir.
+  SDK_PATH = None
+  for sdk_path in paths:
+    if os.path.exists(sdk_path):
+      SDK_PATH = os.path.realpath(sdk_path)
+      break
+  if SDK_PATH is None:
+    # The SDK could not be found in any known location.
+    sys.stderr.write("The Google App Engine SDK could not be found!\n")
+    sys.stderr.write("See README for installation instructions.\n")
+    sys.exit(1)
+  if SDK_PATH == os.path.join(PARENT_DIR, 'google_appengine'):
+    logging.warn('Loading the SDK from the \'google_appengine\' subdirectory '
+                 'is now deprecated!')
+    logging.warn('Please move the SDK to a subdirectory named '
+                 '\'.google_appengine\' instead.')
+    logging.warn('See README for further details.')
+  # Add the SDK and the libraries within it to the system path.
+  EXTRA_PATHS = [
+      SDK_PATH,
+      os.path.join(SDK_PATH, 'lib', 'antlr3'),
+      os.path.join(SDK_PATH, 'lib', 'django'),
+      os.path.join(SDK_PATH, 'lib', 'webob'),
+      os.path.join(SDK_PATH, 'lib', 'yaml', 'lib'),
+  ]
+  # Add SDK paths at the start of sys.path, but after the local directory which
+  # was added to the start of sys.path on line 50 above. The local directory
+  # must come first to allow the local imports to override the SDK and
+  # site-packages directories.
+  sys.path = sys.path[0:1] + EXTRA_PATHS + sys.path[1:]
+  from google.appengine.api import apiproxy_stub_map
+
+# Look for a zipped copy of Django.
+have_django_zip = False
+django_zip_path = os.path.join(PARENT_DIR, 'django.zip')
+if os.path.exists(django_zip_path):
+  have_django_zip = True
+  sys.path.insert(1, django_zip_path)
+
+# Remove the standard version of Django if a local copy has been provided.
+if have_django_zip or os.path.exists(os.path.join(PARENT_DIR, 'django')):
+  for k in [k for k in sys.modules if k.startswith('django')]:
+    del sys.modules[k]
+
+# Must set this env var *before* importing any more of Django.
+os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
+
+from django import VERSION
+from django.conf import settings
+
+from google.appengine.api import yaml_errors
+
+# Flags made available this module
+appid = None
+have_appserver = False
+
+# Hide everything other than the flags above and the install function.
+__all__ = ("appid", "have_appserver", "have_django_zip",
+           "django_zip_path", "InstallAppengineHelperForDjango")
+
+
+INCOMPATIBLE_COMMANDS = ["adminindex", "createcachetable", "dbshell",
+                         "inspectdb", "runfcgi", "syncdb", "validate"]
+
+
+def LoadAppengineEnvironment():
+  """Loads the appengine environment.
+
+  Returns:
+    This function has no return value, but it sets the following parameters on
+    this package:
+    - appid: The name of the application.
+    - have_appserver: Boolean parameter which is True if the code is being run
+        from within the appserver environment.
+  """
+  global appid, have_appserver
+
+  # Detect if we are running under an appserver.
+  have_appserver = False
+  stub = apiproxy_stub_map.apiproxy.GetStub("datastore_v3")
+  if stub:
+    have_appserver = True
+
+  # Load the application identifier.
+  if have_appserver:
+    appid = os.environ.get("APPLICATION_ID", "unknown")
+  else:
+    # Running as manage.py script, read from config file.
+    try:
+      from google.appengine.tools import dev_appserver
+      appconfig, unused_matcher = dev_appserver.LoadAppConfig(PARENT_DIR, {})
+      appid = appconfig.application
+    except (ImportError, yaml_errors.EventListenerYAMLError), e:
+      logging.warn("Could not read the Application ID from app.yaml. "
+                   "This may break things in unusual ways!")
+      # Something went wrong.
+      appid = "unknown"
+
+  logging.debug("Loading application '%s' %s an appserver" %
+                (appid, have_appserver and "with" or "without"))
+
+
+def InstallAppengineDatabaseBackend():
+  """Installs the appengine database backend into Django.
+
+  The appengine database lives in the db/ subdirectory of this package, but is
+  known as "appengine" to Django. This function installs the module where
+  Django expects to find its database backends.
+  """
+  from appengine_django import db
+  sys.modules['django.db.backends.appengine'] = db
+  logging.debug("Installed appengine database backend")
+
+
+def InstallGoogleMemcache():
+  """Installs the Google memcache into Django.
+
+  By default django tries to import standard memcache module.
+  Because appengine memcache is API compatible with Python memcache module,
+  we can trick Django to think it is installed and to use it.
+  
+  Now you can use CACHE_BACKEND = 'memcached://' in settings.py. IP address
+  and port number are not required.
+  """
+  from google.appengine.api import memcache
+  sys.modules['memcache'] = memcache
+  logging.debug("Installed App Engine memcache backend")
+
+
+def InstallDjangoModuleReplacements():
+  """Replaces internal Django modules with App Engine compatible versions."""
+
+  # Replace the session module with a partial replacement overlay using
+  # __path__ so that portions not replaced will fall through to the original
+  # implementation. 
+  try:
+    from django.contrib import sessions
+    orig_path = sessions.__path__[0]
+    sessions.__path__.insert(0, os.path.join(DIR_PATH, 'sessions'))
+    from django.contrib.sessions import backends
+    backends.__path__.append(os.path.join(orig_path, 'backends'))
+  except ImportError:
+    logging.debug("No Django session support available")
+
+  # Replace incompatible dispatchers.
+  import django.core.signals
+  import django.db
+  import django.dispatch.dispatcher
+
+  # Rollback occurs automatically on Google App Engine. Disable the Django
+  # rollback handler.
+  CheckedException = KeyError
+  def _disconnectSignal():
+      django.core.signals.got_request_exception.disconnect(
+          django.db._rollback_on_exception)
+
+  try:
+    _disconnectSignal()
+  except CheckedException, e:
+    logging.debug("Django rollback handler appears to be already disabled.")
+
+def PatchDjangoSerializationModules():
+  """Monkey patches the Django serialization modules.
+
+  The standard Django serialization modules to not correctly handle the
+  datastore models provided by this package. This method installs replacements
+  for selected modules and methods to give Django the capability to correctly
+  serialize and deserialize datastore models.
+  """
+  # These can't be imported until InstallAppengineDatabaseBackend has run.
+  from django.core.serializers import python
+  from appengine_django.serializer.python import Deserializer
+  if not hasattr(settings, "SERIALIZATION_MODULES"):
+    settings.SERIALIZATION_MODULES = {}
+  base_module = "appengine_django"
+  settings.SERIALIZATION_MODULES["xml"] = "%s.serializer.xml" % base_module
+  python.Deserializer = Deserializer
+  PatchDeserializedObjectClass()
+  DisableModelValidation()
+  logging.debug("Installed appengine json and python serialization modules")
+
+
+def PatchDeserializedObjectClass():
+  """Patches the DeserializedObject class.
+
+  The default implementation calls save directly on the django Model base
+  class to avoid pre-save handlers. The model class provided by this package
+  is not derived from the Django Model class and therefore must be called
+  directly.
+
+  Additionally we need to clear the internal _parent attribute as it may
+  contain a FakeParent class that is used to deserialize instances without
+  needing to load the parent instance itself. See the PythonDeserializer for
+  more details.
+  """
+  # This can't be imported until InstallAppengineDatabaseBackend has run.
+  from django.core.serializers import base
+  class NewDeserializedObject(base.DeserializedObject):
+    def save(self, save_m2m=True):
+      self.object.save()
+      self.object._parent = None
+  base.DeserializedObject = NewDeserializedObject
+  logging.debug("Replacement DeserializedObject class installed")
+
+def DisableModelValidation():
+  """Disables Django's model validation routines.
+
+  The model validation is primarily concerned with validating foreign key
+  references. There is no equivalent checking code for datastore References at
+  this time.
+
+  Validation needs to be disabled or serialization/deserialization will fail.
+  """
+  from django.core.management import validation
+  validation.get_validation_errors = lambda x, y=0: 0
+  logging.debug("Django SQL model validation disabled")
+
+def CleanupDjangoSettings():
+  """Removes incompatible entries from the django settings module."""
+
+  # Ensure this module is installed as an application.
+  apps = getattr(settings, "INSTALLED_APPS", ())
+  found = False
+  for app in apps:
+    if app.endswith("appengine_django"):
+      found = True
+      break
+  if not found:
+    logging.warn("appengine_django module is not listed as an application!")
+    apps += ("appengine_django",)
+    setattr(settings, "INSTALLED_APPS", apps)
+    logging.info("Added 'appengine_django' as an application")
+
+  # Ensure the database backend is appropriately configured.
+  dbe = getattr(settings, "DATABASE_ENGINE", "")
+  if dbe != "appengine":
+    settings.DATABASE_ENGINE = "appengine"
+    logging.warn("DATABASE_ENGINE is not configured as 'appengine'. "
+                 "Value overriden!")
+  for var in ["NAME", "USER", "PASSWORD", "HOST", "PORT"]:
+    val = getattr(settings, "DATABASE_%s" % var, "")
+    if val:
+      setattr(settings, "DATABASE_%s" % var, "")
+      logging.warn("DATABASE_%s should be blank. Value overriden!")
+
+  # Remove incompatible middleware modules.
+  mw_mods = list(getattr(settings, "MIDDLEWARE_CLASSES", ()))
+  disallowed_middleware_mods = (
+    'django.middleware.doc.XViewMiddleware',)
+  for modname in mw_mods[:]:
+    if modname in disallowed_middleware_mods:
+      # Currently only the CommonMiddleware has been ported.  As other base
+      # modules are converted, remove from the disallowed_middleware_mods
+      # tuple.
+      mw_mods.remove(modname)
+      logging.warn("Middleware module '%s' is not compatible. Removed!" %
+                   modname)
+  setattr(settings, "MIDDLEWARE_CLASSES", tuple(mw_mods))
+
+  # Remove incompatible application modules
+  app_mods = list(getattr(settings, "INSTALLED_APPS", ()))
+  disallowed_apps = (
+    'django.contrib.contenttypes',
+    'django.contrib.sites',)
+  for app in app_mods[:]:
+    if app in disallowed_apps:
+      app_mods.remove(app)
+      logging.warn("Application module '%s' is not compatible. Removed!" % app)
+  setattr(settings, "INSTALLED_APPS", tuple(app_mods))
+
+  # Remove incompatible session backends.
+  session_backend = getattr(settings, "SESSION_ENGINE", "")
+  if session_backend.endswith("file"):
+    logging.warn("File session backend is not compatible. Overriden "
+                 "to use db backend!")
+    setattr(settings, "SESSION_ENGINE", "django.contrib.sessions.backends.db")
+
+
+def ModifyAvailableCommands():
+  """Removes incompatible commands and installs replacements where possible."""
+  if have_appserver:
+    # Commands are not used when running from an appserver.
+    return
+  from django.core import management
+  project_directory = os.path.join(__path__[0], "../")
+  if have_django_zip:
+    FindCommandsInZipfile.orig = management.find_commands
+    management.find_commands = FindCommandsInZipfile
+  management.get_commands()
+  # Replace startapp command which is set by previous call to get_commands().
+  from appengine_django.management.commands.startapp import ProjectCommand
+  management._commands['startapp'] = ProjectCommand(project_directory) 
+  RemoveCommands(management._commands)
+  logging.debug("Removed incompatible Django manage.py commands")
+
+
+def FindCommandsInZipfile(management_dir):
+    """
+    Given a path to a management directory, returns a list of all the command
+    names that are available.
+
+    This implementation also works when Django is loaded from a zip.
+
+    Returns an empty list if no commands are defined.
+    """
+    zip_marker = ".zip%s" % os.sep
+    if zip_marker not in management_dir:
+      return FindCommandsInZipfile.orig(management_dir)
+
+    # Django is sourced from a zipfile, ask zip module for a list of files.
+    filename, path = management_dir.split(zip_marker)
+    zipinfo = zipfile.ZipFile("%s.zip" % filename)
+
+    # Add commands directory to management path.
+    path = os.path.join(path, "commands")
+
+    # The zipfile module returns paths in the format of the operating system
+    # that created the zipfile! This may not match the path to the zipfile
+    # itself. Convert operating system specific characters to a standard
+    # character (#) to compare paths to work around this.
+    path_normalise = re.compile(r"[/\\]")
+    path = path_normalise.sub("#", path)
+    def _IsCmd(t):
+      """Returns true if t matches the criteria for a command module."""
+      filename = os.path.basename(t)
+      t = path_normalise.sub("#", t)
+      if not t.startswith(path):
+        return False
+      if filename.startswith("_") or not t.endswith(".py"):
+        return False
+      return True
+
+    return [os.path.basename(f)[:-3] for f in zipinfo.namelist() if _IsCmd(f)]
+
+
+def RemoveCommands(command_dict):
+  """Removes incompatible commands from the specified command dictionary."""
+  for cmd in command_dict.keys():
+    if cmd.startswith("sql"):
+      del command_dict[cmd]
+    elif cmd in INCOMPATIBLE_COMMANDS:
+      del command_dict[cmd]
+
+
+def InstallReplacementImpModule():
+  """Install a replacement for the imp module removed by the appserver.
+
+  This is only to find mangement modules provided by applications.
+  """
+  if not have_appserver:
+    return
+  modname = 'appengine_django.replacement_imp'
+  imp_mod = __import__(modname, {}, [], [''])
+  sys.modules['imp'] = imp_mod
+  logging.debug("Installed replacement imp module")
+
+
+def InstallAppengineHelperForDjango():
+  """Installs and Patches all of the classes/methods required for integration.
+
+  If the variable DEBUG_APPENGINE_DJANGO is set in the environment verbose
+  logging of the actions taken will be enabled.
+  """
+  if VERSION < (1, 0, None):
+    logging.error("Django 1.0 or greater is required!")
+    sys.exit(1)
+
+  if os.getenv("DEBUG_APPENGINE_DJANGO"):
+    logging.getLogger().setLevel(logging.DEBUG)
+  else:
+    logging.getLogger().setLevel(logging.INFO)
+  logging.debug("Loading the Google App Engine Helper for Django...")
+
+  # Force Django to reload its settings.
+  settings._target = None
+
+  LoadAppengineEnvironment()
+  InstallReplacementImpModule()
+  InstallAppengineDatabaseBackend()
+  InstallModelForm()
+  InstallGoogleMemcache()
+  InstallDjangoModuleReplacements()
+  PatchDjangoSerializationModules()
+  CleanupDjangoSettings()
+  ModifyAvailableCommands()
+  InstallGoogleSMTPConnection()
+  InstallAuthentication()
+
+  logging.debug("Successfully loaded the Google App Engine Helper for Django.")
+
+
+def InstallGoogleSMTPConnection():
+  from appengine_django import mail as gmail
+  from django.core import mail
+  logging.debug("Installing Google Email Adapter for Django")
+  mail.SMTPConnection = gmail.GoogleSMTPConnection
+  mail.mail_admins = gmail.mail_admins
+  mail.mail_managers = gmail.mail_managers
+
+
+def InstallAuthentication():
+  if "django.contrib.auth" not in settings.INSTALLED_APPS:
+    return
+  try:
+    from appengine_django.auth import models as helper_models
+    from django.contrib.auth import models
+    models.User = helper_models.User
+    models.Group = helper_models.Group
+    models.Permission = helper_models.Permission
+    models.Message = helper_models.Message
+    from django.contrib.auth import middleware as django_middleware
+    from appengine_django.auth.middleware import AuthenticationMiddleware
+    django_middleware.AuthenticationMiddleware = AuthenticationMiddleware
+    from django.contrib.auth import decorators as django_decorators
+    from appengine_django.auth.decorators import login_required
+    django_decorators.login_required = login_required
+    from django.contrib import auth as django_auth
+    from django.contrib.auth import tests as django_tests
+    django_auth.suite = unittest.TestSuite
+    django_tests.suite = unittest.TestSuite
+    logging.debug("Installing authentication framework")
+  except ImportError:
+    logging.debug("No Django authentication support available")
+
+
+def InstallModelForm():
+  """Replace Django ModelForm with the AppEngine ModelForm."""
+  # This MUST happen as early as possible, but after any auth model patching.
+  from google.appengine.ext.db import djangoforms as aeforms
+  try:
+    # pre 1.0
+    from django import newforms as forms
+  except ImportError:
+    from django import forms
+
+  forms.ModelForm = aeforms.ModelForm
+
+  # Extend ModelForm with support for EmailProperty
+  # TODO: This should be submitted to the main App Engine SDK.
+  from google.appengine.ext.db import EmailProperty
+  def get_form_field(self, **kwargs):
+    """Return a Django form field appropriate for an email property."""
+    defaults = {'form_class': forms.EmailField}
+    defaults.update(kwargs)
+    return super(EmailProperty, self).get_form_field(**defaults)
+  EmailProperty.get_form_field = get_form_field