Ticket #1810: django-trunk-r2844-dsn.patch

django/conf/project_template/settings.py

@@ -15 +15 @@
 DATABASE_PASSWORD = ''         # Not used with sqlite3.
 DATABASE_HOST = ''             # Set to empty string for localhost. Not used with sqlite3.
 DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.
+DATABASE_DSN = ''              # Overrides above settings.  Examples: 
+                               # 'postgres://joe:s3cr3t@localhost:8001/addressbook'
+                               # 'sqlite3://:memory:'
+                               # 'sqlite3:///path/to/addressbook.db'
 
 # Local time zone for this installation. All choices can be found here:
 # http://www.postgresql.org/docs/current/static/datetime-keywords.html#DATETIME-TIMEZONE-SET-TABLE

django/conf/__init__.py

@@ -8 +8 @@
 
 import os
 import sys
+import urllib
 from django.conf import global_settings
 
 ENVIRONMENT_VARIABLE = "DJANGO_SETTINGS_MODULE"
@@ -55 +56 @@
 
         # move the time zone info into os.environ
         os.environ['TZ'] = self.TIME_ZONE
+        
+        # inject DSN attributes only if they were declared ...
+        if getattr(self, 'DATABASE_DSN', None):
+            for k,v in parse_dsn(self.DATABASE_DSN).items():
+                if v is not None:
+                    setattr(self, 'DATABASE_%s' % k.upper(), v)
 
+def parse_dsn(dsn):
+    """returns dict with keys: engine, name, user, password, host, port.
+    
+    The keys match the global setting names prefixed with DATABASE_.
+    For example, ``name`` corresponds to ``DATABASE_NAME``.
+    For any value not parsed from the dsn, its value is set to None.
+    
+    Since there is no real RFC on the DSN format (that I could find), 
+    The format here is based on the `URL RFC`_ and typical DSN handling.
+    
+    Some things to note ...  
+    The URL RFC says the ``//`` part of ``scheme://path`` denotes an IP-accessible
+    resource so to make things simpler for local engines, you can leave out 
+    the ``//`` or use ``/`` instead.  
+    Thus, ``sqlite:/:memory:`` is valid, as is ``postgres:``.
+    See the unit tests for a complete list of supported DSN formats.
+    
+    .. _URL RFC : http://www.freesoft.org/CIE/RFC/1738/index.htm
+    
+    @author Kumar McMillan <kumar dot mcmillan / gmail.com>
+    
+    """
+    parsed = dict(engine=None, name=None, user=None, password=None, host=None, port=None)
+    
+    def parse_host(host):
+        if host.find(':') != -1:
+            parsed['host'], parsed['port'] = host.split(':')
+        else:
+            parsed['host'] = host
+    
+    def parse_name(name):
+        if name.find('?') != -1:
+            parsed['name'], query = urllib.splitquery(name)
+            for attr in query.split('&'):
+                k,v = urllib.splitvalue(attr)
+                parsed[k] = urllib.unquote_plus(v)
+        else:
+            parsed['name'] = name
+    
+    def parse_user(user):
+        if user.find(':') != -1:
+            parsed['user'], parsed['password'] = user.split(':')
+            parsed['password'] = urllib.unquote_plus(parsed['password'])
+        else:
+            parsed['user'] = user
+        parsed['user'] = urllib.unquote_plus(parsed['user'])
+    
+    try:
+        esep = dsn.find(':')
+        if esep == -1:
+            raise ValueError, 'no engine detected; expected "engine://"'
+        parsed['engine'] = dsn[0:esep]
+    
+        post_scheme = dsn[esep+1:]
+        # pop off the two optional slashes ...
+        for n in range(2):
+            if len(post_scheme) and post_scheme[0] == '/':
+                post_scheme = post_scheme[1:] 
+        
+        if post_scheme == '':
+            return parsed
+    
+        if parsed['engine'].lower().startswith('sqlite'):
+            # special case since we can't split on slashes :
+            parsed['name'] = post_scheme
+            return parsed
+    
+        parts = post_scheme.split('/')
+        if len(parts) == 1:
+            parse_name(parts[0])
+            return parsed
+    
+        domain, name = parts
+    
+        if domain.find('@') != -1:
+            user, host = domain.split('@')
+            parse_user(user)
+            parse_host(host)
+            parse_name(name)
+            return parsed
+    
+        parse_host(domain)
+        parse_name(name)
+        return parsed
+    except:
+        # append DSN to any exception raised ..
+        etype, val, tb = sys.exc_info()
+        val = "%s (dsn: '%s')" % (val, dsn)
+        raise etype, val, tb
+
 # try to load DJANGO_SETTINGS_MODULE
 try:
     settings_module = os.environ[ENVIRONMENT_VARIABLE]

tests/othertests/conf.py

@@ +1 @@
+
+"""
+test the conf module ...
+
+"""
+
+from django.conf import Settings
+from django.conf import parse_dsn
+from django.conf.project_template import settings as default_settings
+from django.conf import global_settings
+import urllib
+
+def assert_eq(val1, val2):
+    assert val1 == val2, "'%s' != '%s'" % (val1,val2)
+
+def test_parse_dsn():
+    def assert_raises(fn, exc, args=tuple(), kw={}):
+        try: fn(*args,**kw)
+        except exc: pass
+        else: raise AssertionError("exected call to %s to raise %s" % (fn,exc))
+    
+    assert_raises(parse_dsn, ValueError, ('',))
+    assert_raises(parse_dsn, ValueError, ('postgres',))
+    
+    assert_eq( parse_dsn('postgres:'), 
+                dict(   engine='postgres', name=None, user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('postgres:/'), 
+                dict(   engine='postgres', name=None, user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('postgres://'),
+                dict(   engine='postgres', name=None, user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('PostGres://'),
+                dict(   engine='PostGres', name=None, user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('postgres://mydbname'),
+                dict(   engine='postgres', name='mydbname', user=None, 
+                        password=None, host=None, port=None))
+        
+    assert_eq( parse_dsn('sqlite:/:memory:'),
+                dict(   engine='sqlite', name=':memory:', user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('sqlite://:memory:'),
+                dict(   engine='sqlite', name=':memory:', user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('sqlite:///path/to/db'),
+                dict(   engine='sqlite', name='/path/to/db', user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('sqlite3:///path/to/db'),
+                dict(   engine='sqlite3', name='/path/to/db', user=None, 
+                        password=None, host=None, port=None))
+    assert_eq( parse_dsn('sqlite://relpath/to/db'),
+                dict(   engine='sqlite', name='relpath/to/db', user=None, 
+                        password=None, host=None, port=None))
+    
+    assert_eq( parse_dsn('mysql://myhost/dbname'),
+                dict(   engine='mysql', name='dbname', user=None, 
+                        password=None, host='myhost', port=None))
+    assert_eq( parse_dsn('mysql://me@myhost/dbname'),
+                dict(   engine='mysql', name='dbname', user='me', 
+                        password=None, host='myhost', port=None))
+    assert_eq( parse_dsn('mysql://me:mypass@myhost/dbname'),
+                dict(   engine='mysql', name='dbname', user='me', 
+                        password='mypass', host='myhost', port=None))
+    assert_eq( parse_dsn('mysql://me:mypass@myhost:9000/dbname'),
+                dict(   engine='mysql', name='dbname', user='me', 
+                        password='mypass', host='myhost', port='9000'))
+    
+    # always decode ?? or do it lazily.  right now we are doing it always
+    p = parse_dsn('postgres://%s:%s@localhost/mydbname' % \
+                        (   urllib.quote_plus('wil/@:dman'), 
+                            urllib.quote_plus('//craazy%@passW')))
+    assert_eq( p, dict( engine='postgres', name='mydbname', user='wil/@:dman', 
+                        password='//craazy%@passW', host='localhost', port=None))
+    # check a literal password with percent sign ...
+    assert_eq( parse_dsn('postgres://me:me%4pas@localhost/mydbname'),
+                dict(   engine='postgres', name='mydbname', user='me', 
+                        password='me%4pas', host='localhost', port=None))
+                        
+    p = parse_dsn(  'mysql:///?host=localhost&name=dbname&'
+                    'user=willy&password=pzzwd&port=8000')
+    assert_eq( p, dict( engine='mysql', name='dbname', user='willy', 
+                        password='pzzwd', host='localhost', port='8000'))
+    p = parse_dsn(  'mysql:///dbname?host=localhost&'
+                    'user=willy&password=%s&port=8000' % urllib.quote('pa@swd'))
+    assert_eq( p, dict( engine='mysql', name='dbname', user='willy', 
+                        password='pa@swd', host='localhost', port='8000'))
+    # just a sanity check to make sure ? params override ...
+    p = parse_dsn(  'mysql://noop:bad@otherhost:81/?host=localhost&name=db&'
+                    'user=me&password=cheese&port=80')
+    assert_eq( p, dict( engine='mysql', name='db', user='me', 
+                        password='cheese', host='localhost', port='80'))
+    
+def test_database_settings():
+    global global_settings, default_settings
+    
+    # this is silly.  decouple Settings() a little more?
+    saved_global_settings = global_settings
+    saved_default_settings = default_settings
+    try:
+        settings_path = 'django.conf.project_template.settings'
+    
+        my_settings = default_settings
+        my_settings.DATABASE_DSN = 'postgres://me:secr3t@supercool.com.fr:8001/postcards'
+    
+        s = Settings(settings_path)
+        assert_eq( s.DATABASE_ENGINE, 'postgres')
+        assert_eq( s.DATABASE_NAME, 'postcards')
+        assert_eq( s.DATABASE_USER, 'me')
+        assert_eq( s.DATABASE_PASSWORD, 'secr3t')
+        assert_eq( s.DATABASE_HOST, 'supercool.com.fr')
+        assert_eq( s.DATABASE_PORT, '8001')
+    
+        # we also want to only override what the dsn declares :
+        my_settings.DATABASE_DSN = 'postgres://me@supercool.com/postcards'
+        my_settings.DATABASE_USER = 'kumar'
+        my_settings.DATABASE_PASSWORD = 'boggle'
+    
+        s = Settings(settings_path)
+        assert_eq( s.DATABASE_USER, 'me')
+        assert_eq( s.DATABASE_PASSWORD, 'boggle')
+    finally:
+        global_settings = saved_global_settings
+        default_settings = saved_default_settings
+
+# hmm ..
+test_parse_dsn()
+test_database_settings()
+ No newline at end of file

docs/settings.txt

@@ -282 +282 @@
 
 The username to use when connecting to the database. Not used with SQLite.
 
+DATABASE_DSN
+------------
+
+Default: ``''`` (Empty string)
+
+DSN (Data Source Name) string to set all configuration values at once.
+For example, ``postgres://joe:s3cr3t@localhost:8001/addressbook`` will set the following :
+
+- ``DATABASE_ENGINE='postgres'``
+- ``DATABASE_USER='joe'``
+- ``DATABASE_PASSWORD='s3cr3t'``
+- ``DATABASE_HOST='localhost'``
+- ``DATABASE_PORT='8001'``
+- ``DATABASE_NAME='addressbook'``
+
+Examples of other valid DSNs :
+
+- ``sqlite3://:memory:`` or ``sqlite3:/:memory:``
+- ``sqlite3:///path/to/my/db``
+- ``mysql:///?host=localhost&user=joe&password=s3cr3t&port=8001&name=addressbook``
+- ``postgres:`` (i.e. everything blank, tell postgres to open a default connection for the current user)
+
+Any value retrieved from parsing a non-empty DSN string will replace a value 
+already set in its corresponding variable.  In other words, ``mysql://joe@localhost/joedb`` 
+will replace the values (if any) of DATABASE_ENGINE, DATABASE_USER, 
+DATABASE_HOST and DATABASE_NAME.  However, it will **not** replace a value 
+in DATABASE_PORT.  Also note that *USER* and *PASSWORD* must be url encoded 
+if they contain characters like ``@``, ``:``, etc (see built-in ``urllib.quote_plus()``).
+
 DATE_FORMAT
 -----------