Migration needed. Refactored the config.configValue model into server.ServerConfig (that's what the config model were used for anyway). The new model can handle arbitrary data structures through pickle. Run ./manage.py migrate to sync your database with the new setup.

Moved Connect screens (the text screen first seen when connecting) away from the database and into a module in gamesrc/world. This module allows for conveniently adding new connect screens on the fly. More than one screen in the given module will mean a random screen is used.

src/server/admin.py

@@ -0,0 +1,18 @@
+#
+# This sets up how models are displayed 
+# in the web admin interface. 
+#
+
+from django.contrib import admin
+from src.config.models import ServerConfig
+
+class ServerConfigAdmin(admin.ModelAdmin):
+    "Custom admin for server configs"
+    list_display = ('db_key', 'db_value')
+    list_display_links = ('db_key')
+    ordering = ['db_key', 'db_value']
+    search_fields = ['db_key']
+    save_as = True 
+    save_on_top = True   
+    list_select_related = True 
+admin.site.register(ServerConfig, ServerConfigAdmin)

src/server/initial_setup.py

@@ -9,17 +9,17 @@ Everything starts at handle_setup()
 from django.contrib.auth.models import User
 from django.core import management
 from django.conf import settings
-from src.config.models import ConfigValue
+from src.server.models import ServerConfig
 from src.help.models import HelpEntry
 from src.utils import create 
 
 def create_config_values():
     """
     Creates the initial config values.
-    """
-    ConfigValue.objects.conf("default_home", "2")
-    ConfigValue.objects.conf("site_name", settings.SERVERNAME)
-    ConfigValue.objects.conf("idle_timeout", settings.IDLE_TIMEOUT)
+    """    
+    ServerConfig.objects.conf("default_home", "2")
+    ServerConfig.objects.conf("site_name", settings.SERVERNAME)
+    ServerConfig.objects.conf("idle_timeout", settings.IDLE_TIMEOUT)
 
 def get_god_user():
     """
@@ -196,7 +196,7 @@ def handle_setup(last_step):
     if not settings.IMPORT_MUX_HELP:
         # skip importing of the MUX helpfiles, they are 
         # not interesting except for developers.
-        del setup_queue[5]
+        del setup_queue[4]
 
     #print " Initial setup: %s steps." % (len(setup_queue)) 
 
@@ -228,7 +228,7 @@ def handle_setup(last_step):
                 
 
             raise 
-        ConfigValue.objects.conf("last_initial_setup_step", last_step + num + 1) 
+        ServerConfig.objects.conf("last_initial_setup_step", last_step + num + 1) 
     # We got through the entire list. Set last_step to -1 so we don't
     # have to run this again.
-    ConfigValue.objects.conf("last_initial_setup_step", -1) 
+    ServerConfig.objects.conf("last_initial_setup_step", -1) 

src/server/manager.py

@@ -0,0 +1,31 @@
+"""
+Custom manager for ServerConfig objects.
+"""
+from django.db import models
+
+class ServerConfigManager(models.Manager):
+    """
+    This gives some access methods to search and edit
+    the configvalue database. 
+
+    If no match is found, return default. 
+    """
+    def conf(self, key=None, value=None, delete=False, default=None):
+        """
+        Access and manipulate config values
+        """
+        if not key:
+            return self.all()
+        elif delete == True:
+            for conf in self.filter(db_key=key):
+                conf.delete()
+        elif value != None:             
+            conf = self.filter(db_key=key)
+            if not conf:                
+                conf = self.model(db_key=key)
+            conf.value = value # this will pickle 
+        else:
+            conf = self.filter(db_key=key)
+            if not conf:
+                return default
+            return conf[0].value

src/server/migrations/0001_rename_config_table_to_server_table.py

@@ -0,0 +1,46 @@
+# encoding: utf-8
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models, utils
+import pickle
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        try:
+            db.rename_table("config_configvalue", "server_serverconfig")    
+            for conf in orm.ServerConfig.objects.all():
+                conf.db_value = pickle.dumps(conf.db_value)
+                conf.save()
+        except utils.DatabaseError:
+            # this will happen if we start db from scratch (the config
+            # app will then already be gone and no data is to be transferred)
+            # So instead of renaming the old we instead have to manually create the new model.
+            # Adding model 'ServerConfig' 
+            db.create_table('server_serverconfig', (
+                    ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+                    ('db_key', self.gf('django.db.models.fields.CharField')(unique=True, max_length=64)),
+                    ('db_value', self.gf('django.db.models.fields.TextField')(blank=True)),
+                    ))
+            db.send_create_signal('server', ['ServerConfig'])
+            
+    def backwards(self, orm):
+        raise RuntimeError("This migration cannot be reversed.")
+
+    models = {
+        'config.configvalue': {
+            'Meta': {'object_name': 'ConfigValue'},
+            'db_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100'}),
+            'db_value': ('django.db.models.fields.TextField', [], {}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'server.serverconfig': {
+            'Meta': {'object_name': 'ServerConfig'},
+            'db_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '64'}),
+            'db_value': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        }
+    }
+
+    complete_apps = ['config', 'server']

src/server/models.py

@@ -0,0 +1,112 @@
+"""
+
+Server Configuration flags
+
+This holds persistent server configuration flags.
+
+Config values should usually be set through the 
+manager's conf() method. 
+
+"""
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+from django.db import models
+from src.utils.idmapper.models import SharedMemoryModel
+from src.utils import logger, utils
+from src.server.manager import ServerConfigManager
+
+#------------------------------------------------------------
+#
+# ServerConfig
+#
+#------------------------------------------------------------
+            
+class ServerConfig(SharedMemoryModel):
+    """
+    On-the fly storage of global settings. 
+
+    Properties defined on ServerConfig:
+      key - main identifier
+      value - value stored in key. This is a pickled storage.
+
+    """
+
+    #
+    # ServerConfig database model setup
+    #
+    #
+    # These database fields are all set using their corresponding properties,
+    # named same as the field, but withtout the db_* prefix.
+
+    # main name of the database entry
+    db_key = models.CharField(max_length=64, unique=True)
+    # config value
+    db_value = models.TextField(blank=True)
+
+    objects = ServerConfigManager()
+        
+    # Wrapper properties to easily set database fields. These are
+    # @property decorators that allows to access these fields using
+    # normal python operations (without having to remember to save()
+    # etc). So e.g. a property 'attr' has a get/set/del decorator
+    # defined that allows the user to do self.attr = value, 
+    # value = self.attr and del self.attr respectively (where self 
+    # is the object in question).
+        
+    # key property (wraps db_key)
+    #@property
+    def key_get(self):
+        "Getter. Allows for value = self.key"
+        return self.db_key
+    #@key.setter
+    def key_set(self, value):
+        "Setter. Allows for self.key = value"
+        self.db_key = value
+        self.save()
+    #@key.deleter
+    def key_del(self):
+        "Deleter. Allows for del self.key. Deletes entry."
+        self.delete()
+    key = property(key_get, key_set, key_del)
+
+    # value property (wraps db_value)
+    #@property
+    def value_get(self):
+        "Getter. Allows for value = self.value"
+        return pickle.loads(str(self.db_value))
+    #@value.setter
+    def value_set(self, value):
+        "Setter. Allows for self.value = value"
+        if utils.has_parent('django.db.models.base.Model', value):
+            # we have to protect against storing db objects.
+            logger.log_errmsg("ServerConfig cannot store db objects! (%s)" % value)
+            return 
+        self.db_value = pickle.dumps(value)
+        self.save()
+    #@value.deleter
+    def value_del(self):
+        "Deleter. Allows for del self.value. Deletes entry."        
+        self.delete()
+    value = property(value_get, value_set, value_del)
+
+    class Meta:
+        "Define Django meta options"
+        verbose_name = "Server Config value"
+        verbose_name_plural = "Server Config values"
+
+    # 
+    # ServerConfig other methods 
+    #
+
+    def __unicode__(self):
+        return "%s : %s" % (self.key, self.value)
+
+    def store(key, value):
+        """
+        Wrap the storage (handles pickling)
+        """
+        self.key = key
+        self.value = value

src/server/server.py

@@ -21,7 +21,7 @@ from twisted.web import server, static
 from django.db import connection
 from django.conf import settings
 from src.utils import reloads
-from src.config.models import ConfigValue
+from src.server.models import ServerConfig
 from src.server.sessionhandler import SESSIONS
 from src.server import initial_setup
 
@@ -123,7 +123,7 @@ class Evennia(object):
         This attempts to run the initial_setup script of the server.
         It returns if this is not the first time the server starts.
         """
-        last_initial_setup_step = ConfigValue.objects.conf('last_initial_setup_step')
+        last_initial_setup_step = ServerConfig.objects.conf('last_initial_setup_step')
         if not last_initial_setup_step:
             # None is only returned if the config does not exist,
             # i.e. this is an empty DB that needs populating.

src/server/sessionhandler.py

@@ -17,7 +17,7 @@ registering themselves with this module.
 """
 from django.conf import settings
 from django.contrib.auth.models import User
-from src.config.models import ConfigValue
+from src.server.models import ServerConfig
 
 ALLOW_MULTISESSION = settings.ALLOW_MULTISESSION
 
@@ -144,15 +144,15 @@ class SessionHandler(object):
         """
         if num == None:
             # show the current value. This also syncs it.                         
-            return int(ConfigValue.objects.conf('nr_sessions', default=0))            
+            return int(ServerConfig.objects.conf('nr_sessions', default=0))            
         elif num == 0:
             # reset value to 0
-            ConfigValue.objects.conf('nr_sessions', 0)
+            ServerConfig.objects.conf('nr_sessions', 0)
         else:
             # add/remove session count from value
-            add = int(ConfigValue.objects.conf('nr_sessions', default=0))
+            add = int(ServerConfig.objects.conf('nr_sessions', default=0))
             num = max(0, num + add)
-            ConfigValue.objects.conf('nr_sessions', str(num))
+            ServerConfig.objects.conf('nr_sessions', str(num))
 
     def player_count(self):
         """