cubicweb: comparison cwconfig.py

equal deleted inserted replaced

-:48f468f33704
+:e4580e5f0703
 .. _ResourceMode:
 Resource mode
 -------------
-A resource *mode* is a predifined set of settings for various resources
+A resource *mode* is a predefined set of settings for various resources
 directories, such as cubes, instances, etc. to ease development with the
 framework. There are two running modes with *CubicWeb*:
-* 'user', resources are searched / created in the user home directory:
+* **system**: resources are searched / created in the system directories (eg
+usually requiring root access):
+- instances are stored in :file:`<INSTALL_PREFIX>/etc/cubicweb.d`
+- temporary files (such as pid file) in :file:`/var/run/cubicweb`
+where `<INSTALL_PREFIX>` is the detected installation prefix ('/usr/local' for
+instance).
+* **user**: resources are searched / created in the user home directory:
 - instances are stored in :file:`~/etc/cubicweb.d`
 - temporary files (such as pid file) in :file:`/tmp`
-* 'system', resources are searched / created in the system directories (eg
-usually requiring root access):
-- instances are stored in :file:`<INSTALL_PREFIX>/etc/cubicweb.d`
-- temporary files (such as pid file) in :file:`/var/run/cubicweb`
-where `<INSTALL_PREFIX>` is the detected installation prefix ('/usr/local' for
-instance).
 Notice that each resource path may be explicitly set using an environment
 variable if the default doesn't suit your needs. Here are the default resource
 directories that are affected according to mode:
-* 'system': ::
+* **system**: ::
 CW_INSTANCES_DIR = <INSTALL_PREFIX>/etc/cubicweb.d/
 CW_INSTANCES_DATA_DIR = /var/lib/cubicweb/instances/
 CW_RUNTIME_DIR = /var/run/cubicweb/
-* 'user': ::
+* **user**: ::
 CW_INSTANCES_DIR = ~/etc/cubicweb.d/
 CW_INSTANCES_DATA_DIR = ~/etc/cubicweb.d/
 CW_RUNTIME_DIR = /tmp
-Cubes search path is also affected, see the :ref:Cube section.
+Cubes search path is also affected, see the :ref:`Cube` section.
-By default, the mode automatically set to 'user' if a :file:`.hg` directory is found
+By default, the mode automatically set to `user` if a :file:`.hg` directory is found
-in the cubicweb package, else it's set to 'system'. You can force this by setting
+in the cubicweb package, else it's set to `system`. You can force this by setting
-the :envvar:`CW_MODE` environment variable to either 'user' or 'system' so you can
+the :envvar:`CW_MODE` environment variable to either `user` or `system` so you can
 easily:
 * use system wide installation but user specific instances and all, without root
 privileges on the system (`export CW_MODE=user`)
 CONFIGURATIONS = []
 SMTP_LOCK = Lock()
-class metaconfiguration(type):
-"""metaclass to automaticaly register configuration"""
-def __new__(mcs, name, bases, classdict):
-cls = super(metaconfiguration, mcs).__new__(mcs, name, bases, classdict)
-if classdict.get('name'):
-CONFIGURATIONS.append(cls)
-return cls
 def configuration_cls(name):
 """return the configuration class registered with the given name"""
 try:
 return [c for c in CONFIGURATIONS if c.name == name][0]
 _USR_INSTALL = _INSTALL_PREFIX == '/usr'
 class CubicWebNoAppConfiguration(ConfigurationMixIn):
 """base class for cubicweb configuration without a specific instance directory
 """
-__metaclass__ = metaconfiguration
 # to set in concrete configuration
 name = None
 # log messages format (see logging module documentation for available keys)
 log_format = '%(asctime)s - (%(name)s) %(levelname)s: %(message)s'
 # the format below can be useful to debug multi thread issues:
 ('log-threshold',
 {'type' : 'string', # XXX use a dedicated type?
 'default': 'WARNING',
 'help': 'server\'s log level',
 'group': 'main', 'level': 1,
+}),
+('umask',
+{'type' : 'int',
+'default': 077,
+'help': 'permission umask for files created by the server',
+'group': 'main', 'level': 2,
 }),
 # pyro options
 ('pyro-instance-id',
 {'type' : 'string',
 'default': Method('default_instance_id'),
 extrapath[cubesdir] = 'cubes'
 return extrapath
 @classmethod
 def cube_dir(cls, cube):
-"""return the cube directory for the given cube id,
+"""return the cube directory for the given cube id, raise
-raise `ConfigurationError` if it doesn't exists
+`ConfigurationError` if it doesn't exist
 """
 for directory in cls.cubes_search_path():
 cubedir = join(directory, cube)
 if exists(cubedir):
 return cubedir
-raise ConfigurationError('no cube %s in %s' % (cube, cls.cubes_search_path()))
+raise ConfigurationError('no cube %r in %s' % (
+cube, cls.cubes_search_path()))
 @classmethod
 def cube_migration_scripts_dir(cls, cube):
 """cube migration scripts directory"""
 return join(cls.cube_dir(cube), 'migration')
 cubes.__path__ = cls.cubes_search_path()
 except ImportError:
 return # cubes dir doesn't exists
 @classmethod
+def load_available_configs(cls):
+from logilab.common.modutils import load_module_from_file
+for conffile in ('web/webconfig.py',  'etwist/twconfig.py',
+'server/serverconfig.py',):
+if exists(join(CW_SOFTWARE_ROOT, conffile)):
+load_module_from_file(join(CW_SOFTWARE_ROOT, conffile))
+@classmethod
 def load_cwctl_plugins(cls):
 from logilab.common.modutils import load_module_from_file
 cls.cls_adjust_sys_path()
 for ctlfile in ('web/webctl.py',  'etwist/twctl.py',
 'server/serverctl.py',
 'devtools/devctl.py', 'goa/goactl.py'):
 if exists(join(CW_SOFTWARE_ROOT, ctlfile)):
 try:
 load_module_from_file(join(CW_SOFTWARE_ROOT, ctlfile))
 except ImportError, err:
-cls.info('could not import the command provider %s (cause : %s)' %
+cls.error('could not import the command provider %s: %s',
-(ctlfile, err))
+ctlfile, err)
 cls.info('loaded cubicweb-ctl plugin %s', ctlfile)
 for cube in cls.available_cubes():
 oldpluginfile = join(cls.cube_dir(cube), 'ecplugin.py')
 pluginfile = join(cls.cube_dir(cube), 'ccplugin.py')
 initfile = join(cls.cube_dir(cube), '__init__.py')
 vregpath.append(path + '.py')
 return vregpath
 def __init__(self, debugmode=False):
 register_stored_procedures()
+self._cubes = None
 super(CubicWebNoAppConfiguration, self).__init__()
 self.debugmode = debugmode
 self.adjust_sys_path()
 self.load_defaults()
 # will be properly initialized later by _gettext_init
 from logilab.common.modutils import load_module_from_modpath, modpath_from_file
 module = load_module_from_modpath(modpath_from_file(sitefile, self.extrapath))
 self.debug('%s loaded', sitefile)
 return module
-def eproperty_definitions(self):
+def cwproperty_definitions(self):
 cfg = self.persistent_options_configuration()
 for section, options in cfg.options_by_section():
 section = section.lower()
 for optname, optdict, value in options:
 key = '%s.%s' % (section, optname)
 """return the instance identifier, useful for option which need this
 as default value
 """
 return None
+_cubes = None
+def init_cubes(self, cubes):
+assert self._cubes is None, self._cubes
+self._cubes = self.reorder_cubes(cubes)
+# load cubes'__init__.py file first
+for cube in cubes:
+__import__('cubes.%s' % cube)
+self.load_site_cubicweb()
+def cubes(self):
+"""return the list of cubes used by this instance
+result is ordered from the top level cubes to inner dependencies
+cubes
+"""
+assert self._cubes is not None, 'cubes not initialized'
+return self._cubes
+def cubes_path(self):
+"""return the list of path to cubes used by this instance, from outer
+most to inner most cubes
+"""
+return [self.cube_dir(p) for p in self.cubes()]
 class CubicWebConfiguration(CubicWebNoAppConfiguration):
 """base class for cubicweb server and web configurations"""
 if CubicWebNoAppConfiguration.mode == 'user':
 @classmethod
 def config_for(cls, appid, config=None, debugmode=False):
 """return a configuration instance for the given instance identifier
 """
+cls.load_available_configs()
 config = config or guess_configuration(cls.instance_home(appid))
 configcls = configuration_cls(config)
 return configcls(appid, debugmode)
 @classmethod
 iddir = self.instances_dir()
 iddir = abspath(os.environ.get('CW_INSTANCES_DATA_DIR', iddir))
 return join(iddir, self.appid)
 def init_cubes(self, cubes):
-assert self._cubes is None, self._cubes
+super(CubicWebConfiguration, self).init_cubes(cubes)
-self._cubes = self.reorder_cubes(cubes)
-# load cubes'__init__.py file first
-for cube in cubes:
-__import__('cubes.%s' % cube)
-self.load_site_cubicweb()
 # reload config file in cases options are defined in cubes __init__
 # or site_cubicweb files
 self.load_file_configuration(self.main_config_file())
 # configuration initialization hook
 self.load_configuration()
-def cubes(self):
-"""return the list of cubes used by this instance
-result is ordered from the top level cubes to inner dependencies
-cubes
-"""
-assert self._cubes is not None
-return self._cubes
-def cubes_path(self):
-"""return the list of path to cubes used by this instance, from outer
-most to inner most cubes
-"""
-return [self.cube_dir(p) for p in self.cubes()]
 def add_cubes(self, cubes):
 """add given cubes to the list of used cubes"""
 if not isinstance(cubes, list):
 cubes = list(cubes)
 def update_cb_stack(self, stack):
 assert len(stack) == 1
 stack[0] = self.source_execute
 def as_sql(self, backend, args):
-raise NotImplementedError('source only callback')
+raise NotImplementedError(
+'This callback is only available for BytesFileSystemStorage '
+'managed attribute. Is FSPATH() argument BFSS managed?')
 def source_execute(self, source, session, value):
 fpath = source.binary_to_str(value)
 try:
 return Binary(fpath)

branch	oldstable
changeset 7074	e4580e5f0703
parent 7031	a04621040cad
child 7083	b8e35cde46e9