cubicweb: comparison cwconfig.py

equal deleted inserted replaced

-:ea75dfe32317
+:e951a860eeaf
 ('encoding',
 {'type' : 'string',
 'default': 'UTF-8',
 'help': _('user interface encoding'),
 'group': 'ui', 'sitewide': True,
 }),
 ('language',
 {'type' : 'string',
 'default': 'en',
 'vocabulary': Method('available_languages'),
 'help': _('language of the user interface'),
 'group': 'ui',
 }),
 ('date-format',
 {'type' : 'string',
 'default': '%Y/%m/%d',
 'help': _('how to format date in the ui ("man strftime" for format description)'),
 'group': 'ui',
 }),
 ('datetime-format',
 {'type' : 'string',
 'default': '%Y/%m/%d %H:%M',
 'help': _('how to format date and time in the ui ("man strftime" for format description)'),
 'group': 'ui',
 }),
 ('time-format',
 {'type' : 'string',
 'default': '%H:%M',
 'help': _('how to format time in the ui ("man strftime" for format description)'),
 'group': 'ui',
 }),
 ('float-format',
 {'type' : 'string',
 'default': '%.3f',
 'help': _('how to format float numbers in the ui'),
 'group': 'ui',
 }),
 ('default-text-format',
 {'type' : 'choice',
 'choices': ('text/plain', 'text/rest', 'text/html'),
 'default': 'text/html', # use fckeditor in the web ui
 'help': _('default text format for rich text fields.'),
 'group': 'ui',
 }),
 ('short-line-size',
 {'type' : 'int',
 'default': 40,
 'help': _('maximum number of characters in short description'),
 )
 def register_persistent_options(options):
 global PERSISTENT_OPTIONS
 PERSISTENT_OPTIONS = merge_options(PERSISTENT_OPTIONS + options)
 CFGTYPE2ETYPE_MAP = {
 'string': 'String',
 'choice': 'String',
 'yn':     'Boolean',
 'int':    'Int',
 'float' : 'Float',
 }
 class CubicWebNoAppConfiguration(ConfigurationMixIn):
 """base class for cubicweb configuration without a specific instance directory
 """
 __metaclass__ = metaconfiguration
 # to set in concrete configuration
 'help': 'comma separated list of identifiers of application objects (<registry>.<oid>) to disable',
 'group': 'appobjects', 'inputlevel': 2,
 }),
 )
 # static and class methods used to get application independant resources ##
 @staticmethod
 def cubicweb_version():
 """return installed cubicweb version"""
 from logilab.common.changelog import Version
 from cubicweb import __pkginfo__
 version = __pkginfo__.numversion
 assert len(version) == 3, version
 return Version(version)
 @staticmethod
 def persistent_options_configuration():
 return Configuration(options=PERSISTENT_OPTIONS)
 @classmethod
 library views and data may be found)
 """
 if cls.mode in ('dev', 'test') and not os.environ.get('APYCOT_ROOT'):
 return join(CW_SOFTWARE_ROOT, 'web')
 return cls.cube_dir('shared')
 @classmethod
 def i18n_lib_dir(cls):
 """return application's i18n directory"""
 if cls.mode in ('dev', 'test') and not os.environ.get('APYCOT_ROOT'):
 return join(CW_SOFTWARE_ROOT, 'i18n')
 for directory in cls.cubes_search_path():
 for cube in os.listdir(directory):
 if isdir(join(directory, cube)) and not cube in ('CVS', '.svn', 'shared', '.hg'):
 cubes.add(cube)
 return sorted(cubes)
 @classmethod
 def cubes_search_path(cls):
 """return the path of directories where cubes should be searched"""
 path = []
 try:
 except KeyError:
 pass
 if not cls.CUBES_DIR in path:
 path.append(cls.CUBES_DIR)
 return path
 @classmethod
 def cube_dir(cls, cube):
 """return the cube directory for the given cube id,
 raise ConfigurationError if it doesn't exists
 """
 @classmethod
 def cube_migration_scripts_dir(cls, cube):
 """cube migration scripts directory"""
 return join(cls.cube_dir(cube), 'migration')
 @classmethod
 def cube_pkginfo(cls, cube):
 """return the information module for the given cube"""
 cube = CW_MIGRATION_MAP.get(cube, cube)
 try:
 raise ConfigurationError('unable to find packaging information for '
 'cube %s (%s: %s)' % (cube, ex.__class__.__name__, ex))
 @classmethod
 def cube_version(cls, cube):
 """return the version of the cube located in the given directory
 """
 from logilab.common.changelog import Version
 version = cls.cube_pkginfo(cube).numversion
 assert len(version) == 3, version
 return Version(version)
 try:
 deps.remove(cube)
 except KeyError:
 continue
 return tuple(reversed(cubes))
 @classmethod
 def cls_adjust_sys_path(cls):
 """update python path if necessary"""
 cubes_parent_dir = normpath(join(cls.CUBES_DIR, '..'))
 if not cubes_parent_dir in sys.path:
 try:
 __import__('cubes.%s' % cube)
 except:
 cls.exception('while loading cube %s', cube)
 else:
 cls.warning('no __init__ file in cube %s', cube)
 @classmethod
 def init_available_cubes(cls):
 """cubes may register some sources (svnfile for instance) in their
 __init__ file, so they should be loaded early in the startup process
 for cube in cls.available_cubes():
 try:
 __import__('cubes.%s' % cube)
 except Exception, ex:
 cls.warning("can't init cube %s: %s", cube, ex)
 cubicweb_vobject_path = set(['entities'])
 cube_vobject_path = set(['entities'])
 @classmethod
 def build_vregistry_path(cls, templpath, evobjpath=None, tvobjpath=None):
 if exists(path):
 vregpath.append(path)
 elif exists(path + '.py'):
 vregpath.append(path + '.py')
 return vregpath
 def __init__(self):
 ConfigurationMixIn.__init__(self)
 self.adjust_sys_path()
 self.load_defaults()
 self.translations = {}
 def adjust_sys_path(self):
 self.cls_adjust_sys_path()
 def init_log(self, logthreshold=None, debug=False,
 logfile=None, syslog=False):
 """init the log service"""
 if logthreshold is None:
 if debug:
 logthreshold = 'DEBUG'
 def vregistry_path(self):
 """return a list of files or directories where the registry will look
 for application objects. By default return nothing in NoApp config.
 """
 return []
 def eproperty_definitions(self):
 cfg = self.persistent_options_configuration()
 for section, options in cfg.options_by_section():
 section = section.lower()
 for optname, optdict, value in options:
 default = cfg.option_default(optname, optdict)
 pdef = {'type': type, 'vocabulary': vocab, 'default': default,
 'help': optdict['help'],
 'sitewide': optdict.get('sitewide', False)}
 yield key, pdef
 def map_option(self, optdict):
 try:
 vocab = optdict['choices']
 except KeyError:
 vocab = optdict.get('vocabulary')
 if isinstance(vocab, Method):
 vocab = getattr(self, vocab.method, ())
 return CFGTYPE2ETYPE_MAP[optdict['type']], vocab
 class CubicWebConfiguration(CubicWebNoAppConfiguration):
 """base class for cubicweb server and web configurations"""
 INSTANCE_DATA_DIR = None
 if CubicWebNoAppConfiguration.mode == 'test':
 root = os.environ['APYCOT_ROOT']
 REGISTRY_DIR = '%s/etc/cubicweb.d/' % root
 RUNTIME_DIR = '/tmp/'
 # for some commands (creation...) we don't want to initialize gettext
 set_language = True
 # set this to true to avoid false error message while creating an application
 creating = False
 options = CubicWebNoAppConfiguration.options + (
 ('log-file',
 {'type' : 'string',
 'default': Method('default_log_file'),
 'help': 'file where output logs should be written',
 'help': 'listening port of the SMTP mail server',
 'group': 'email', 'inputlevel': 1,
 }),
 ('sender-name',
 {'type' : 'string',
 'default': Method('default_application_id'),
 'help': 'name used as HELO name for outgoing emails from the \
 repository.',
 'group': 'email', 'inputlevel': 2,
 }),
 ('sender-addr',
 @classmethod
 def runtime_dir(cls):
 """run time directory for pid file..."""
 return env_path('CW_RUNTIME', cls.RUNTIME_DIR, 'run time')
 @classmethod
 def registry_dir(cls):
 """return the control directory"""
 return env_path('CW_REGISTRY', cls.REGISTRY_DIR, 'registry')
 def instance_data_dir(cls):
 """return the instance data directory"""
 return env_path('CW_INSTANCE_DATA',
 cls.INSTANCE_DATA_DIR or cls.REGISTRY_DIR,
 'additional data')
 @classmethod
 def migration_scripts_dir(cls):
 """cubicweb migration scripts directory"""
 return env_path('CW_MIGRATION', cls.MIGRATION_DIR, 'migration')
 """return a configuration instance for the given application identifier
 """
 config = config or guess_configuration(cls.application_home(appid))
 configcls = configuration_cls(config)
 return configcls(appid)
 @classmethod
 def possible_configurations(cls, appid):
 """return the name of possible configurations for the given
 application id
 """
 home = cls.application_home(appid)
 return possible_configurations(home)
 @classmethod
 def application_home(cls, appid):
 """return the home directory of the application with the given
 application id
 """
 'twisted'   : ('common', 'web'),}
 @classmethod
 def accept_mode(cls, mode):
 #assert mode in cls.MODES, mode
 return mode in cls.MCOMPAT[cls.name]
 # default configuration methods ###########################################
 def default_application_id(self):
 """return the application identifier, useful for option which need this
 as default value
 """
 return self.appid
 except IOError:
 path = '%s-%s.log' % (basepath, i)
 i += 1
 return path
 return '/var/log/cubicweb/%s-%s.log' % (self.appid, self.name)
 def default_pid_file(self):
 """return default path to the pid file of the application'server"""
 return join(self.runtime_dir(), '%s-%s.pid' % (self.appid, self.name))
 # instance methods used to get application specific resources #############
 def __init__(self, appid):
 self.appid = appid
 CubicWebNoAppConfiguration.__init__(self)
 self._cubes = None
 self._site_loaded = set()
 sys.path.insert(0, self.apphome)
 @property
 def apphome(self):
 return join(self.registry_dir(), self.appid)
 @property
 def appdatahome(self):
 return join(self.instance_data_dir(), self.appid)
 def init_cubes(self, cubes):
 assert self._cubes is None
 self._cubes = self.reorder_cubes(cubes)
 # load cubes'__init__.py file first
 for cube in cubes:
 # 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)
 self._cubes = self.reorder_cubes(list(self._cubes) + cubes)
 def main_config_file(self):
 """return application's control configuration file"""
 return join(self.apphome, '%s.conf' % self.name)
 def save(self):
 """write down current configuration"""
 self.generate_config(open(self.main_config_file(), 'w'))
 @cached
 infos = []
 for pkg in self.cubes():
 version = self.cube_version(pkg)
 infos.append('%s-%s' % (pkg, version))
 return md5.new(';'.join(infos)).hexdigest()
 def load_site_cubicweb(self):
 """load (web?) application's specific site_cubicweb file"""
 for path in reversed([self.apphome] + self.cubes_path()):
 sitefile = join(path, 'site_cubicweb.py')
 if exists(sitefile) and not sitefile in self._site_loaded:
 sitefile = join(path, 'site_erudi.py')
 if exists(sitefile) and not sitefile in self._site_loaded:
 self._load_site_cubicweb(sitefile)
 self._site_loaded.add(sitefile)
 self.warning('site_erudi.py is deprecated, should be renamed to site_cubicweb.py')
 def _load_site_cubicweb(self, sitefile):
 context = {}
 execfile(sitefile, context, context)
 self.info('%s loaded', sitefile)
 # cube specific options
 if context.get('options'):
 self.register_options(context['options'])
 self.load_defaults()
 def load_configuration(self):
 """load application's configuration files"""
 super(CubicWebConfiguration, self).load_configuration()
 if self.apphome and self.set_language:
 # init gettext
 self._set_language()
 def init_log(self, logthreshold=None, debug=False, force=False):
 """init the log service"""
 if not force and hasattr(self, '_logging_initialized'):
 return
 self._logging_initialized = True
 for path in glob(join(self.apphome, 'i18n',
 '*', 'LC_MESSAGES', 'cubicweb.mo')):
 lang = path.split(os.sep)[-3]
 if lang != 'en':
 yield lang
 def _set_language(self):
 """set language for gettext"""
 from gettext import translation
 path = join(self.apphome, 'i18n')
 for language in self.available_languages():
 try:
 tr = translation('cubicweb', path, languages=[language])
 self.translations[language] = tr.ugettext
 except (ImportError, AttributeError, IOError):
 self.exception('localisation support error for language %s',
 language)
 def vregistry_path(self):
 """return a list of files or directories where the registry will look
 for application objects
 """
 templpath = list(reversed(self.cubes_path()))
 def set_sources_mode(self, sources):
 if not 'all' in sources:
 print 'warning: ignoring specified sources, requires a repository '\
 'configuration'
 def migration_handler(self):
 """return a migration handler instance"""
 from cubicweb.common.migration import MigrationHelper
 return MigrationHelper(self, verbosity=self.verbosity)
 sourcedirs = [join(path, 'i18n') for path in self.cubes_path()]
 sourcedirs.append(self.i18n_lib_dir())
 return i18n.compile_i18n_catalogs(sourcedirs, i18ndir, langs)
 set_log_methods(CubicWebConfiguration, logging.getLogger('cubicweb.configuration'))
 # alias to get a configuration instance from an application id
 application_configuration = CubicWebConfiguration.config_for

branch	tls-sprint
changeset 1446	e951a860eeaf
parent 1263	01152fffd593
child 1493	8270580b65a0
child 1520	b097057e629d