Merged [5614] and [5622] from mcr@sandelman.ca: added dajaxice.

 - Legacy-Id: 5786
Note: SVN reference [5614] has been migrated to Git commit 7e0e027

Note: SVN reference [5622] has been migrated to Git commit bde631c

Author: levkowetz

dajaxice/__init__.py

@@ -0,0 +1 @@
+VERSION = (0, 2, 0, 0, 'beta')

dajaxice/core/Dajaxice.py

@@ -0,0 +1,181 @@
+import logging
+
+from django.conf import settings
+
+# Python 2.7 has an importlib with import_module.
+# For older Pythons, Django's bundled copy provides it.
+# For older Django's dajaxice reduced_import_module.
+try:
+    from importlib import import_module
+except:
+    try:
+        from django.utils.importlib import import_module
+    except:
+        from dajaxice.utils import simple_import_module as import_module
+
+log = logging.getLogger('dajaxice.DajaxiceRequest')
+
+
+class DajaxiceFunction(object):
+
+    def __init__(self, name, path, doc=None):
+        self.name = name
+        self.path = path
+        self.doc = doc
+
+    def get_callable_path(self):
+        return '%s.%s' % (self.path.replace('.ajax', ''), self.name)
+
+    def __cmp__(self, other):
+        return (self.name == other.name and self.path == other.path)
+
+
+class DajaxiceModule(object):
+    def __init__(self, module):
+        self.functions = []
+        self.sub_modules = []
+        self.name = module[0]
+
+        sub_module = module[1:]
+        if len(sub_module) != 0:
+            self.add_submodule(sub_module)
+
+    def get_module(self, module):
+        """
+        Recursively get_module util we found it.
+        """
+        if len(module) == 0:
+            return self
+
+        for dajaxice_module in self.sub_modules:
+            if dajaxice_module.name == module[0]:
+                return dajaxice_module.get_module(module[1:])
+        return None
+
+    def add_function(self, function):
+        self.functions.append(function)
+
+    def has_sub_modules(self):
+        return len(self.sub_modules) > 0
+
+    def add_submodule(self, module):
+        """
+        Recursively add_submodule, if it's not registered, create it.
+        """
+        if len(module) == 0:
+            return
+        else:
+            sub_module = self.exist_submodule(module[0])
+
+            if type(sub_module) == int:
+                self.sub_modules[sub_module].add_submodule(module[1:])
+            else:
+                self.sub_modules.append(DajaxiceModule(module))
+
+    def exist_submodule(self, name):
+        """
+        Check if submodule name was already registered.
+        """
+        for module in self.sub_modules:
+            if module.name == name:
+                return self.sub_modules.index(module)
+        return False
+
+
+class Dajaxice(object):
+    def __init__(self):
+        self._registry = []
+        self._callable = []
+
+        for function in getattr(settings, 'DAJAXICE_FUNCTIONS', ()):
+            function = function.rsplit('.', 1)
+            self.register_function(function[0], function[1])
+
+    def register(self, function):
+        self.register_function(function.__module__, function.__name__, function.__doc__)
+
+    def register_function(self, module, name, doc=None):
+        """
+        Register function at 'module' depth
+        """
+        #Create the dajaxice function.
+        function = DajaxiceFunction(name=name, path=module, doc=doc)
+
+        #Check for already registered functions.
+        full_path = '%s.%s' % (module, name)
+        if full_path in self._callable:
+            log.warning('%s already registered as dajaxice function.' % full_path)
+            return
+
+        self._callable.append(full_path)
+
+        #Dajaxice path without ajax.
+        module_without_ajax = module.replace('.ajax', '').split('.')
+
+        #Register module if necessary.
+        exist_module = self._exist_module(module_without_ajax[0])
+
+        if type(exist_module) == int:
+            self._registry[exist_module].add_submodule(module_without_ajax[1:])
+        else:
+            self._registry.append(DajaxiceModule(module_without_ajax))
+
+        #Register Function
+        module = self.get_module(module_without_ajax)
+        if module:
+            module.add_function(function)
+
+    def get_module(self, module):
+        """
+        Recursively get module from registry
+        """
+        for dajaxice_module in self._registry:
+            if dajaxice_module.name == module[0]:
+                return dajaxice_module.get_module(module[1:])
+        return None
+
+    def is_callable(self, name):
+        return name in self._callable
+
+    def _exist_module(self, module_name):
+        for module in self._registry:
+            if module.name == module_name:
+                return self._registry.index(module)
+        return False
+
+    def get_functions(self):
+        return self._registry
+
+
+LOADING_DAJAXICE = False
+
+
+def dajaxice_autodiscover():
+    """
+    Auto-discover INSTALLED_APPS ajax.py modules and fail silently when
+    not present.
+    NOTE: dajaxice_autodiscover was inspired/copied from django.contrib.admin autodiscover
+    """
+    global LOADING_DAJAXICE
+    if LOADING_DAJAXICE:
+        return
+    LOADING_DAJAXICE = True
+
+    import imp
+    from django.conf import settings
+
+    for app in settings.INSTALLED_APPS:
+
+        try:
+            app_path = import_module(app).__path__
+        except AttributeError:
+            continue
+
+        try:
+            imp.find_module('ajax', app_path)
+        except ImportError:
+            continue
+
+        import_module("%s.ajax" % app)
+
+    LOADING_DAJAXICE = False

dajaxice/core/DajaxiceRequest.py

@@ -0,0 +1,214 @@
+#----------------------------------------------------------------------
+# Copyright (c) 2009-2011 Benito Jorge Bastida
+# All rights reserved.
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions are
+#  met:
+#
+#    o Redistributions of source code must retain the above copyright
+#      notice, this list of conditions, and the disclaimer that follows.
+#
+#    o Redistributions in binary form must reproduce the above copyright
+#      notice, this list of conditions, and the following disclaimer in
+#      the documentation and/or other materials provided with the
+#      distribution.
+#
+#    o Neither the name of Digital Creations nor the names of its
+#      contributors may be used to endorse or promote products derived
+#      from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS
+#  IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+#  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+#  PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL
+#  CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+#  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+#  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+#  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+#  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+#  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+#  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+#  DAMAGE.
+#----------------------------------------------------------------------
+
+import os
+import sys
+import logging
+import traceback
+
+from django.conf import settings
+from django.utils import simplejson
+from django.http import HttpResponse
+
+from dajaxice.core import dajaxice_functions
+from dajaxice.exceptions import FunctionNotCallableError, DajaxiceImportError
+
+log = logging.getLogger('dajaxice.DajaxiceRequest')
+
+# Python 2.7 has an importlib with import_module.
+# For older Pythons, Django's bundled copy provides it.
+# For older Django's dajaxice reduced_import_module.
+try:
+    from importlib import import_module
+except:
+    try:
+        from django.utils.importlib import import_module
+    except:
+        from dajaxice.utils import simple_import_module as import_module
+
+
+def safe_dict(d):
+    """
+    Recursively clone json structure with UTF-8 dictionary keys
+    http://www.gossamer-threads.com/lists/python/bugs/684379
+    """
+    if isinstance(d, dict):
+        return dict([(k.encode('utf-8'), safe_dict(v)) for k, v in d.iteritems()])
+    elif isinstance(d, list):
+        return [safe_dict(x) for x in d]
+    else:
+        return d
+
+
+class DajaxiceRequest(object):
+
+    def __init__(self, request, call):
+        call = call.rsplit('.', 1)
+        self.app_name = call[0]
+        self.method = call[1]
+        self.request = request
+
+        self.project_name = os.environ['DJANGO_SETTINGS_MODULE'].split('.')[0]
+        self.module = "%s.ajax" % self.app_name
+        self.full_name = "%s.%s" % (self.module, self.method)
+
+    @staticmethod
+    def get_js_functions():
+        return dajaxice_functions.get_functions()
+
+    @staticmethod
+    def get_media_prefix():
+        return getattr(settings, 'DAJAXICE_MEDIA_PREFIX', "dajaxice")
+
+    @staticmethod
+    def get_functions():
+        return getattr(settings, 'DAJAXICE_FUNCTIONS', ())
+
+    @staticmethod
+    def get_debug():
+        return getattr(settings, 'DAJAXICE_DEBUG', True)
+
+    @staticmethod
+    def get_notify_exceptions():
+        return getattr(settings, 'DAJAXICE_NOTIFY_EXCEPTIONS', False)
+
+    @staticmethod
+    def get_cache_control():
+        if settings.DEBUG:
+            return 0
+        return getattr(settings, 'DAJAXICE_CACHE_CONTROL', 5 * 24 * 60 * 60)
+
+    @staticmethod
+    def get_xmlhttprequest_js_import():
+        return getattr(settings, 'DAJAXICE_XMLHTTPREQUEST_JS_IMPORT', True)
+
+    @staticmethod
+    def get_json2_js_import():
+        return getattr(settings, 'DAJAXICE_JSON2_JS_IMPORT', True)
+
+    @staticmethod
+    def get_exception_message():
+        return getattr(settings, 'DAJAXICE_EXCEPTION', u'DAJAXICE_EXCEPTION')
+
+    @staticmethod
+    def get_js_docstrings():
+        return getattr(settings, 'DAJAXICE_JS_DOCSTRINGS', False)
+
+    def _is_callable(self):
+        """
+        Return if the request function was registered.
+        """
+        return dajaxice_functions.is_callable(self.full_name)
+
+    def _get_ajax_function(self):
+        """
+        Return a callable ajax function.
+        This function should be imported according the Django version.
+        """
+        return self._modern_get_ajax_function()
+
+    def _modern_get_ajax_function(self):
+        """
+        Return a callable ajax function.
+        This function uses django.utils.importlib
+        """
+        self.module_import_name = "%s.%s" % (self.project_name, self.module)
+        try:
+            return self._modern_import()
+        except:
+            self.module_import_name = self.module
+            return self._modern_import()
+
+    def _modern_import(self):
+        try:
+            mod = import_module(self.module_import_name)
+            return mod.__getattribute__(self.method)
+        except:
+            raise DajaxiceImportError()
+
+    def process(self):
+        """
+        Process the dajax request calling the apropiate method.
+        """
+        if self._is_callable():
+            log.debug('Function %s is callable' % self.full_name)
+
+            argv = self.request.POST.get('argv')
+            if argv != 'undefined':
+                try:
+                    argv = simplejson.loads(self.request.POST.get('argv'))
+                    argv = safe_dict(argv)
+                except Exception, e:
+                    log.error('argv exception %s' % e)
+                    argv = {}
+            else:
+                argv = {}
+
+            log.debug('argv %s' % argv)
+
+            try:
+                thefunction = self._get_ajax_function()
+                response = '%s' % thefunction(self.request, **argv)
+
+            except Exception, e:
+                trace = '\n'.join(traceback.format_exception(*sys.exc_info()))
+                log.error(trace)
+                response = '%s' % DajaxiceRequest.get_exception_message()
+
+                if DajaxiceRequest.get_notify_exceptions():
+                    self.notify_exception(self.request, sys.exc_info())
+
+            log.info('response: %s' % response)
+            return HttpResponse(response, mimetype="application/x-json")
+
+        else:
+            log.debug('Function %s is not callable' % self.full_name)
+            raise FunctionNotCallableError(name=self.full_name)
+
+    def notify_exception(self, request, exc_info):
+        """
+        Send Exception traceback to ADMINS
+        Similar to BaseHandler.handle_uncaught_exception
+        """
+        from django.conf import settings
+        from django.core.mail import mail_admins
+
+        subject = 'Error (%s IP): %s' % ((request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS and 'internal' or 'EXTERNAL'), request.path)
+        try:
+            request_repr = repr(request)
+        except:
+            request_repr = "Request repr() unavailable"
+
+        trace = '\n'.join(traceback.format_exception(*(exc_info or sys.exc_info())))
+        message = "%s\n\n%s" % (trace, request_repr)
+        mail_admins(subject, message, fail_silently=True)