Merge lp:~jnaous/rpc4django/urlgroups into lp:rpc4django

[Jad Naous]

I've implemented the blueprint for enforcing specific methods to be available at specific URLs. I've also written tests for it. I've also allowed arbitrary keyword args to be passed to RPC methods because this can be useful for passing parameters from the URL at which an RPC is called.

Unmerged revisions

16. By Jad Naous <jnaous@jadsm> on 2010-11-20

Implement isolation across URLs

15. By Jad Naous <jnaous@jadsm> on 2010-11-20

removed test file

14. By Jad Naous <jnaous@jadsm> on 2010-11-20

test

=== modified file 'example/urls.py'
--- example/urls.py	2010-03-29 05:04:00 +0000
+++ example/urls.py	2010-11-20 07:51:10 +0000
@@ -1,4 +1,5 @@
 from django.conf.urls.defaults import *
+from rpc4django.utils import rpc_url
 
 # Uncomment the next two lines to enable the admin:
 # from django.contrib import admin
@@ -14,6 +15,6 @@
 
     # Uncomment the next line to enable the admin:
     # (r'^admin/(.*)', admin.site.root),
-    ('^$', 'rpc4django.views.serve_rpc_request'),
-    ('^RPC2$', 'rpc4django.views.serve_rpc_request'),
+    rpc_url('^$'),
+    rpc_url('^RPC2$'),
 )
 
=== modified file 'rpc4django/rpcdispatcher.py'
--- rpc4django/rpcdispatcher.py	2010-10-27 04:36:20 +0000
+++ rpc4django/rpcdispatcher.py	2010-11-20 07:51:10 +0000
@@ -8,7 +8,6 @@
 import inspect
 import platform
 import pydoc
-import types
 import xmlrpclib
 from xmlrpclib import Fault
 from django.contrib.auth import authenticate, login, logout
@@ -43,25 +42,16 @@
     
         @rpcmethod()
         @rpcmethod(name='myns.myFuncName', signature=['int','int'])
-        @rpcmethod(permission='add_group')
+        @rpcmethod(permission='add_group', url_name="my_url_name")
         
     '''
     
     def set_rpcmethod_info(method):
         method.is_rpcmethod = True
-        method.signature = []
-        method.permission = None
-        method.external_name = getattr(method, '__name__')
-
-        if 'name' in kwargs:
-            method.external_name = kwargs['name']
-
-        if 'signature' in kwargs:
-            method.signature = kwargs['signature']
-            
-        if 'permission' in kwargs:
-            method.permission = kwargs['permission']
-
+        method.external_name = kwargs.get("name", getattr(method, '__name__'))
+        method.signature = kwargs.get('signature', [])
+        method.permission = kwargs.get('permission', None)
+        method.url_name = kwargs.get("url_name", "root")
         return method
     return set_rpcmethod_info
 
@@ -210,9 +200,9 @@
       
     '''
     
-    def __init__(self, url='', apps=[], restrict_introspection=False, restrict_ootb_auth=True):
+    def __init__(self, url_name='root', restrict_introspection=False, restrict_ootb_auth=True):
         version = platform.python_version_tuple()
-        self.url = url
+        self.url_name = url_name
         self.rpcmethods = []        # a list of RPCMethod objects
         self.jsonrpcdispatcher = JSONRPCDispatcher()
         self.xmlrpcdispatcher = XMLRPCDispatcher()
@@ -226,8 +216,6 @@
         if not restrict_ootb_auth:
             self.register_method(self.system_login)
             self.register_method(self.system_logout)
-            
-        self.register_rpcmethods(apps)
         
     @rpcmethod(name='system.describe', signature=['struct'])
     def system_describe(self):
@@ -237,7 +225,6 @@
         
         description = {}
         description['serviceType'] = 'RPC4Django JSONRPC+XMLRPC'
-        description['serviceURL'] = self.url,
         description['methods'] = [{'name': method.name, 
                                    'summary': method.help, 
                                    'params': method.get_params(),
@@ -314,32 +301,6 @@
             
         return False
                
-    def register_rpcmethods(self, apps):
-        '''
-        Scans the installed apps for methods with the rpcmethod decorator
-        Adds these methods to the list of methods callable via RPC
-        '''    
-        
-        for appname in apps:
-            # check each app for any rpcmethods
-            app = __import__(appname, globals(), locals(), ['*'])
-            for obj in dir(app):
-                method = getattr(app, obj)
-                if callable(method) and \
-                   hasattr(method, 'is_rpcmethod') and \
-                   method.is_rpcmethod == True:
-                    # if this method is callable and it has the rpcmethod
-                    # decorator, add it to the dispatcher
-                    self.register_method(method, method.external_name)
-                elif isinstance(method, types.ModuleType):
-                    # if this is not a method and instead a sub-module,
-                    # scan the module for methods with @rpcmethod
-                    try:
-                        self.register_rpcmethods(["%s.%s" % (appname, obj)])
-                    except ImportError:
-                        pass
-
-    
     def jsondispatch(self, raw_post_data, **kwargs):
         '''
         Sends the post data to :meth:`rpc4django.jsonrpcdispatcher.JSONRPCDispatcher.dispatch`
 
=== modified file 'rpc4django/tests/test_rpcdispatcher.py'
--- rpc4django/tests/test_rpcdispatcher.py	2010-03-29 05:04:00 +0000
+++ rpc4django/tests/test_rpcdispatcher.py	2010-11-20 07:51:10 +0000
@@ -139,24 +139,6 @@
         self.assertEqual(jsondict['id'], 1)
         self.assertEqual(jsondict['result'], 3)
         
-    def test_register_methods(self):
-        self.d.register_rpcmethods(['rpc4django.tests.testmod'])
-        
-        jsontxt = '{"params":[3,1],"method":"subtract","id":1}'
-        resp = self.d.jsondispatch(jsontxt)
-        jsondict = json.loads(resp)
-        self.assertTrue(jsondict['error'] is None)
-        self.assertEqual(jsondict['id'], 1)
-        self.assertEqual(jsondict['result'], 2)
-        
-        jsontxt = '{"params":[3,2],"method":"power","id":99}'
-        resp = self.d.jsondispatch(jsontxt)
-        jsondict = json.loads(resp)
-        self.assertTrue(jsondict['error'] is None)
-        self.assertEqual(jsondict['id'], 99)
-        self.assertEqual(jsondict['result'], 9)
-        
-        
     def test_kwargs(self):
         self.d.register_method(self.kwargstest)
         
 
=== modified file 'rpc4django/tests/test_rpcviews.py'
--- rpc4django/tests/test_rpcviews.py	2010-03-29 05:04:00 +0000
+++ rpc4django/tests/test_rpcviews.py	2010-11-20 07:51:10 +0000
@@ -6,30 +6,57 @@
 
 import unittest
 import xmlrpclib
-from django.test.client import Client
+from django.core.urlresolvers import reverse
 from rpc4django.jsonrpcdispatcher import json, JSONRPC_SERVICE_ERROR
-
-RPCPATH = '/RPC2'
-
-class TestRPCViews(unittest.TestCase):
-
+from rpc4django import views
+from rpc4django.tests.utils import SettingsTestCase
+
+
+class TestRPCViews(SettingsTestCase):
+
+    urls = "rpc4django.tests.test_urls"
+    
     def setUp(self):
-        self.client = Client()
-
+        self.settings_manager.set(
+            INSTALLED_APPS=(
+                "rpc4django",
+                "rpc4django.tests.testmod",
+            ),
+            MIDDLEWARE_CLASSES=(
+                'django.middleware.common.CommonMiddleware',
+                'django.middleware.transaction.TransactionMiddleware',
+                'django.middleware.csrf.CsrfViewMiddleware',
+                'django.contrib.sessions.middleware.SessionMiddleware',
+                'django.contrib.auth.middleware.AuthenticationMiddleware',
+            ),
+            DEBUG_PROPAGATE_EXCEPTIONS=False,
+        )
+        
+        views._register_rpcmethods(
+            [
+                "rpc4django",
+                "rpc4django.tests.testmod",
+            ],
+            restrict_introspection=False,
+            dispatchers=views.dispatchers)
+        
+        self.rpc_path = reverse("serve_rpc_request")
+        self.ns_rpc_path = reverse("my_url_name")
+        
     def test_methodsummary(self):
-        response = self.client.get(RPCPATH)
+        response = self.client.get(self.rpc_path)
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.template.name, 'rpc4django/rpcmethod_summary.html')
     
     def test_xmlrequests(self):
         data = '<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName><params></params></methodCall>'
-        response = self.client.post(RPCPATH, data, 'text/xml')
+        response = self.client.post(self.rpc_path, data, 'text/xml')
         self.assertEqual(response.status_code, 200)
         xmlrpclib.loads(response.content)       # this will throw an exception with bad data
         
     def test_jsonrequests(self):
         data = '{"params":[],"method":"system.listMethods","id":123}'
-        response = self.client.post(RPCPATH, data, 'application/json')
+        response = self.client.post(self.rpc_path, data, 'application/json')
         self.assertEqual(response.status_code, 200)
         jsondict = json.loads(response.content)
         self.assertTrue(jsondict['error'] is None)
@@ -37,7 +64,7 @@
         self.assertTrue(isinstance(jsondict['result'], list))
         
         data = '{"params":[],"method":"system.describe","id":456}'
-        response = self.client.post(RPCPATH, data, 'text/javascript')
+        response = self.client.post(self.rpc_path, data, 'text/javascript')
         self.assertEqual(response.status_code, 200)
         jsondict = json.loads(response.content)
         self.assertTrue(jsondict['error'] is None)
@@ -46,7 +73,7 @@
         
     def test_typedetection(self):
         data = '{"params":[],"method":"system.listMethods","id":123}'
-        response = self.client.post(RPCPATH, data, 'text/plain')
+        response = self.client.post(self.rpc_path, data, 'text/plain')
         self.assertEqual(response.status_code, 200)
         jsondict = json.loads(response.content)
         self.assertTrue(jsondict['error'] is None)
@@ -54,13 +81,13 @@
         self.assertTrue(isinstance(jsondict['result'], list))
         
         data = '<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName><params></params></methodCall>'
-        response = self.client.post(RPCPATH, data, 'text/plain')
+        response = self.client.post(self.rpc_path, data, 'text/plain')
         self.assertEqual(response.status_code, 200)
         xmlrpclib.loads(response.content)       # this will throw an exception with bad data
         
         # jsonrpc request with xmlrpc data (should be error)
         data = '<?xml version="1.0"?><methodCall><methodName>system.listMethods</methodName><params></params></methodCall>'
-        response = self.client.post(RPCPATH, data, 'application/json')
+        response = self.client.post(self.rpc_path, data, 'application/json')
         self.assertEqual(response.status_code, 200)
         jsondict = json.loads(response.content)
         self.assertTrue(jsondict['result'] is None)
@@ -69,7 +96,7 @@
         
         data = '{"params":[],"method":"system.listMethods","id":123}'
         try:
-            response = self.client.post(RPCPATH, data, 'text/xml')
+            response = self.client.post(self.rpc_path, data, 'text/xml')
         except:
             # for some reason, this throws an expat error
             # but only in python 2.4
@@ -83,7 +110,7 @@
         
     def test_badrequests(self):
         data = '{"params":[],"method":"system.methodHelp","id":456}'
-        response = self.client.post(RPCPATH, data, 'application/json')
+        response = self.client.post(self.rpc_path, data, 'application/json')
         self.assertEqual(response.status_code, 200)
         jsondict = json.loads(response.content)
         self.assertTrue(jsondict['error'] is not None)
@@ -92,7 +119,7 @@
         self.assertEqual(jsondict['error']['code'], JSONRPC_SERVICE_ERROR)
         
         data = '<?xml version="1.0"?><methodCall><methodName>method.N0t.Exists</methodName><params></params></methodCall>'
-        response = self.client.post(RPCPATH, data, 'text/xml')
+        response = self.client.post(self.rpc_path, data, 'text/xml')
         self.assertEqual(response.status_code, 200)
         try:
             xmlrpclib.loads(response.content)
@@ -108,9 +135,42 @@
             # options requests can only be tested by django 1.1+
             self.fail('This version of django "%s" does not support http access control' %str(t))
         
-        response = self.client.options(RPCPATH, '', 'text/plain')
+        response = self.client.options(self.rpc_path, '', 'text/plain')
         self.assertEqual(response['Access-Control-Allow-Methods'], 'POST, GET, OPTIONS')
         self.assertEqual(response['Access-Control-Max-Age'], '0')
         
+    def test_good_url_name(self):
+        """
+        Make sure we call functions based on the url they are arriving on. 
+        """
+        data = xmlrpclib.dumps((5, 4), "subtract")
+        response = self.client.post(self.rpc_path, data, 'text/xml')
+        self.assertEqual(response.status_code, 200)
+        result, methname = xmlrpclib.loads(response.content)
+        self.assertEqual(result, (1,))
+        self.assertEqual(methname, None)
+        
+        data = xmlrpclib.dumps((5, 4), "product")
+        response = self.client.post(self.ns_rpc_path, data, 'text/xml')
+        self.assertEqual(response.status_code, 200)
+        result, methname = xmlrpclib.loads(response.content)
+        self.assertEqual(result, (20,))
+        self.assertEqual(methname, None)
+
+    def test_bad_url_name(self):
+        """
+        Make sure we cannot call functions using the wrong url_name.
+        """
+        data = xmlrpclib.dumps((5, 4), "subtract")
+        response = self.client.post(self.ns_rpc_path, data, 'text/xml')
+        
+        self.assertEqual(response.status_code, 200)
+        try:
+            result, methname = xmlrpclib.loads(response.content)
+            self.fail("Expected xmlrpclib Fault")
+        except xmlrpclib.Fault as fault:
+            self.assertEqual(fault.faultCode, 1)
+            self.assertTrue(fault.faultString.endswith('method "subtract" is not supported'))
+        
 if __name__ == '__main__':
     unittest.main()
 \ No newline at end of file
 
=== added file 'rpc4django/tests/test_urls.py'
--- rpc4django/tests/test_urls.py	1970-01-01 00:00:00 +0000
+++ rpc4django/tests/test_urls.py	2010-11-20 07:51:10 +0000
@@ -0,0 +1,12 @@
+'''
+Created on Jun 9, 2010
+
+@author: jnaous
+'''
+from django.conf.urls.defaults import *
+from rpc4django.utils import rpc_url
+
+urlpatterns = patterns("",
+    rpc_url(r"^RPC2/$", name="serve_rpc_request", use_name_for_dispatch=False),
+    rpc_url(r"^my_url/RPC2/$", name="my_url_name"),
+)
 
=== modified file 'rpc4django/tests/testmod/__init__.py'
--- rpc4django/tests/testmod/__init__.py	2010-03-29 05:04:00 +0000
+++ rpc4django/tests/testmod/__init__.py	2010-11-20 07:51:10 +0000
@@ -5,6 +5,6 @@
 def subtract(a, b):
     return a - b
 
-@rpcmethod(signature=['int', 'int', 'int'])
+@rpcmethod(signature=['int', 'int', 'int'], url_name="my_url_name")
 def product(a, b):
     return a * b
 
=== added file 'rpc4django/tests/testmod/models.py'
--- rpc4django/tests/testmod/models.py	1970-01-01 00:00:00 +0000
+++ rpc4django/tests/testmod/models.py	2010-11-20 07:51:10 +0000
@@ -0,0 +1,5 @@
+'''
+Created on Jun 9, 2010
+
+@author: jnaous
+'''
 
=== modified file 'rpc4django/tests/testmod/testsubmod/__init__.py'
--- rpc4django/tests/testmod/testsubmod/__init__.py	2010-03-29 05:04:00 +0000
+++ rpc4django/tests/testmod/testsubmod/__init__.py	2010-11-20 07:51:10 +0000
@@ -3,3 +3,7 @@
 @rpcmethod(signature=['int', 'int', 'int'])
 def power(a, b):
     return a ** b
+
+@rpcmethod(signature=['int', 'int'], url_name="my_url_name")
+def power2(a):
+    return 2 ** a
 
=== added file 'rpc4django/tests/utils.py'
--- rpc4django/tests/utils.py	1970-01-01 00:00:00 +0000
+++ rpc4django/tests/utils.py	2010-11-20 07:51:10 +0000
@@ -0,0 +1,64 @@
+'''
+Created on Nov 19, 2010
+
+http://djangosnippets.org/snippets/1011/
+
+@author: jnaous
+'''
+from django.conf import settings
+from django.core.management import call_command
+from django.db.models import loading
+from django.test import TestCase
+
+NO_SETTING = ('!', None)
+
+class TestSettingsManager(object):
+    """
+    A class which can modify some Django settings temporarily for a
+    test and then revert them to their original values later.
+
+    Automatically handles resyncing the DB if INSTALLED_APPS is
+    modified.
+
+    """
+    def __init__(self):
+        self._original_settings = {}
+
+    def set(self, **kwargs):
+        for k,v in kwargs.iteritems():
+            self._original_settings.setdefault(k, getattr(settings, k,
+                                                          NO_SETTING))
+            setattr(settings, k, v)
+        if 'INSTALLED_APPS' in kwargs:
+            self.syncdb()
+
+    def syncdb(self):
+        loading.cache.loaded = False
+        call_command('syncdb', verbosity=0)
+
+    def revert(self):
+        for k,v in self._original_settings.iteritems():
+            if v == NO_SETTING:
+                delattr(settings, k)
+            else:
+                setattr(settings, k, v)
+        if 'INSTALLED_APPS' in self._original_settings:
+            self.syncdb()
+        self._original_settings = {}
+
+
+class SettingsTestCase(TestCase):
+    """
+    A subclass of the Django TestCase with a settings_manager
+    attribute which is an instance of TestSettingsManager.
+
+    Comes with a tearDown() method that calls
+    self.settings_manager.revert().
+
+    """
+    def __init__(self, *args, **kwargs):
+        super(SettingsTestCase, self).__init__(*args, **kwargs)
+        self.settings_manager = TestSettingsManager()
+    
+    def tearDown(self):
+        self.settings_manager.revert()
 
=== added file 'rpc4django/utils.py'
--- rpc4django/utils.py	1970-01-01 00:00:00 +0000
+++ rpc4django/utils.py	2010-11-20 07:51:10 +0000
@@ -0,0 +1,20 @@
+'''
+Created on Jun 9, 2010
+
+@author: jnaous
+'''
+from django.conf.urls.defaults import url
+
+def rpc_url(regex, kwargs=None, name=None, prefix='',
+            use_name_for_dispatch=True):
+    """
+    Wrapper around C{django.conf.urls.defaults.url} to add the C{name} parameter
+    to C{kwargs} as "url_name", and to automatically assign the C{view}.
+    C{use_name_for_dispatch} controls whether or not to add C{name} to C{kwargs}
+    """
+    if name != None and use_name_for_dispatch:
+        if kwargs == None:
+            kwargs = {}
+        kwargs["url_name"] = name
+    view = "rpc4django.views.serve_rpc_request"
+    return url(regex, view, kwargs, name, prefix)
 
=== modified file 'rpc4django/views.py'
--- rpc4django/views.py	2010-10-27 04:36:20 +0000
+++ rpc4django/views.py	2010-11-20 07:51:10 +0000
@@ -1,23 +1,23 @@
 '''
 The main entry point for RPC4Django. Usually, the user simply puts
-:meth:`serve_rpc_request <rpc4django.views.serve_rpc_request>` into ``urls.py``
+:meth:`rpc_url <rpc4django.utils.rpc_url>` into ``urls.py``
 
 ::
 
     urlpatterns = patterns('', 
         # rpc4django will need to be in your Python path  
-        (r'^RPC2$', 'rpc4django.views.serve_rpc_request'), 
+        rpc_url(r'^RPC2$', name="my_url_name"), 
     )
     
 '''
 
 import logging
+import types
 from xml.dom.minidom import parseString
 from xml.parsers.expat import ExpatError
 from django.http import HttpResponse, Http404, HttpResponseForbidden
 from django.shortcuts import render_to_response
 from django.conf import settings
-from django.core.urlresolvers import reverse, NoReverseMatch
 from rpcdispatcher import RPCDispatcher
 from __init__ import version
 
@@ -45,7 +45,25 @@
 # these will be scanned for @rpcmethod decorators
 APPS = getattr(settings, 'INSTALLED_APPS', [])
 
-def check_request_permission(request, request_format='xml'):
+logger = logging.getLogger("rpc4django.views")
+
+class NonExistingDispatcher(Exception):
+    """Raised when the dispatcher for a particular name is not found."""
+    def __init__(self, path, url_name):
+        super(NonExistingDispatcher, self).__init__(
+            "URL name '%s' is not used in any rpcmethod,\
+ however, the URL '%s' uses it." % (url_name, path))
+        self.path = path
+        self.url_name = url_name
+
+def get_dispatcher(path, url_name):
+    try:
+        dispatcher = dispatchers[url_name]
+    except KeyError:
+        raise NonExistingDispatcher(path, url_name)
+    return dispatcher
+
+def check_request_permission(request, request_format='xml', url_name="root"):
     '''
     Checks whether this user has permission to call a particular method
     This method does not check method call validity. That is done later
@@ -54,11 +72,13 @@
     
     - ``request`` - a django HttpRequest object
     - ``request_format`` - the request type: 'json' or 'xml' 
+    - ``url_name`` - the name of the url at which this request was received
     
     Returns ``False`` if permission is denied and ``True`` otherwise
     '''
     
     user = getattr(request, 'user', None)
+    dispatcher = get_dispatcher(request.path, url_name)
     methods = dispatcher.list_methods()
     method_name = dispatcher.get_method_name(request.raw_post_data, \
                                              request_format)
@@ -69,20 +89,20 @@
             # this is the method the user is calling
             # time to check the permissions
             if method.permission is not None:
-                logging.debug('Method "%s" is protected by permission "%s"' \
+                logger.debug('Method "%s" is protected by permission "%s"' \
                               %(method.name, method.permission))
                 if user is None:
                     # user is only none if not using AuthenticationMiddleware
-                    logging.warn('AuthenticationMiddleware is not enabled')
+                    logger.warn('AuthenticationMiddleware is not enabled')
                     response = False
                 elif not user.has_perm(method.permission):
                     # check the permission against the permission database
-                    logging.info('User "%s" is NOT authorized' %(str(user)))
+                    logger.info('User "%s" is NOT authorized' %(str(user)))
                     response = False
                 else:
-                    logging.debug('User "%s" is authorized' %(str(user)))
+                    logger.debug('User "%s" is authorized' %(str(user)))
             else:
-                logging.debug('Method "%s" is unprotected' %(method.name))
+                logger.debug('Method "%s" is unprotected' %(method.name))
                 
             break
     
@@ -111,8 +131,8 @@
         return False
     
     if LOG_REQUESTS_RESPONSES:
-        logging.info('Unrecognized content-type "%s"' %conttype)
-        logging.info('Analyzing rpc request data to get content type')
+        logger.info('Unrecognized content-type "%s"' %conttype)
+        logger.info('Analyzing rpc request data to get content type')
     
     # analyze post data to see whether it is xml or json
     # this is slower than if the content-type was set properly
@@ -124,7 +144,7 @@
     
     return False
 
-def serve_rpc_request(request):
+def serve_rpc_request(request, url_name="root", **kwargs):
     '''
     Handles rpc calls based on the content type of the request or
     returns the method documentation page if the request
@@ -134,38 +154,42 @@
     
     ``request``
         the Django HttpRequest object
-        
+    ``url_name``
+        the name of the url at which the request arrived
+    
     '''
-
+    
+    dispatcher = get_dispatcher(request.path, url_name)
+    
     if request.method == "POST" and len(request.POST) > 0:
         # Handle POST request with RPC payload
         
         if LOG_REQUESTS_RESPONSES:
-            logging.debug('Incoming request: %s' %str(request.raw_post_data))
+            logger.debug('Incoming request: %s' % str(request.raw_post_data))
             
         if is_xmlrpc_request(request):
             if RESTRICT_XML:
                 raise Http404
             
-            if not check_request_permission(request, 'xml'):
+            if not check_request_permission(request, 'xml', url_name=url_name):
                 return HttpResponseForbidden()
             
-            resp = dispatcher.xmldispatch(request.raw_post_data, \
-                                          request=request)
+            resp = dispatcher.xmldispatch(request.raw_post_data,
+                                          request=request, **kwargs)
             response_type = 'text/xml'
         else:
             if RESTRICT_JSON:
                 raise Http404
             
-            if not check_request_permission(request, 'json'):
+            if not check_request_permission(request, 'json', url_name=url_name):
                 return HttpResponseForbidden()
             
-            resp = dispatcher.jsondispatch(request.raw_post_data, \
-                                           request=request)
+            resp = dispatcher.jsondispatch(request.raw_post_data,
+                                           request=request, **kwargs)
             response_type = 'application/json'
             
         if LOG_REQUESTS_RESPONSES:
-            logging.debug('Outgoing %s response: %s' %(response_type, resp))
+            logger.debug('Outgoing %s response: %s' %(response_type, resp))
         
         return HttpResponse(resp, response_type)
     elif request.method == 'OPTIONS':
@@ -185,7 +209,7 @@
                     request.META.get('HTTP_ACCESS_CONTROL_REQUEST_HEADERS', '')
                     
         if LOG_REQUESTS_RESPONSES:
-            logging.debug('Outgoing HTTP access response to: %s' %(origin))
+            logger.debug('Outgoing HTTP access response to: %s' %(origin))
                     
         return response
     else:
@@ -199,7 +223,7 @@
         methods = dispatcher.list_methods()
         template_data = {
             'methods': methods,
-            'url': URL,
+            'url': request.path,
             
             # rpc4django version
             'version': version(),
@@ -225,13 +249,41 @@
 if csrf_exempt is not None:
     serve_rpc_request = csrf_exempt(serve_rpc_request)
 
-# reverse the method for use with system.describe and ajax
-try:
-    URL = reverse(serve_rpc_request)
-except NoReverseMatch:
-    URL = ''
+def _register_rpcmethods(apps, restrict_introspection=False, restrict_ootb_auth=True, dispatchers={}):
+    '''
+    Scans the installed apps for methods with the rpcmethod decorator
+    Adds these methods to the list of methods callable via RPC
+    '''
     
-# instantiate the rpcdispatcher -- this examines the INSTALLED_APPS
-# for any @rpcmethod decorators and adds them to the callable methods
-dispatcher = RPCDispatcher(URL, APPS, RESTRICT_INTROSPECTION, RESTRICT_OOTB_AUTH) 
+    for appname in apps:
+        # check each app for any rpcmethods
+        app = __import__(appname, globals(), locals(), ['*'])
+        for obj in dir(app):
+            method = getattr(app, obj)
+            if callable(method) and \
+               getattr(method, 'is_rpcmethod', False) == True:
+                # if this method is callable and it has the rpcmethod
+                # decorator, add it to the dispatcher
+                if method.url_name not in dispatchers:
+                    logger.debug("Registered URL name '%s'" % method.url_name)
+                    dispatchers[method.url_name] = RPCDispatcher(
+                        method.url_name, restrict_introspection,
+                        restrict_ootb_auth)
+                logger.debug(
+                    "Registered method '%s' to URL name '%s'"
+                    % (method.external_name, method.url_name))
+                dispatchers[method.url_name].register_method(
+                    method, method.external_name)
+            elif isinstance(method, types.ModuleType):
+                # if this is not a method and instead a sub-module,
+                # scan the module for methods with @rpcmethod
+                try:
+                    _register_rpcmethods(
+                        ["%s.%s" % (appname, obj)], 
+                        restrict_introspection, restrict_ootb_auth, dispatchers)
+                except ImportError:
+                    pass
+    return dispatchers
+
+dispatchers = _register_rpcmethods(APPS, RESTRICT_INTROSPECTION, RESTRICT_OOTB_AUTH)