def sort_middlewares(self, middlewares):
# middleware process
# middleware can be defined as
# middleware_name = middleware_class_path[, order]
# middleware_name = <empty> will be skip
m = []
for v in middlewares:
if not v:
continue
order = None
if isinstance(v, (list, tuple)):
if len(v) > 2:
raise ServosError('Middleware %r difinition is not right' %
v)
middleware_path = v[0]
if len(v) == 2:
order = v[1]
else:
middleware_path = v
cls = import_attr(middleware_path)
if order is None:
order = getattr(cls, 'ORDER', 500)
m.append((order, cls))
m.sort(cmp=lambda x, y: cmp(x[0], y[0]))
return [x[1] for x in m]
def __getattr__(self, name):
if name in self.__objects:
return self.__objects[name]
if name not in settings[self.__section]:
raise ServosError("Object %s is not existed!" % name)
obj = import_attr(settings[self.__section].get(name))
self.__objects[name] = obj
return obj
def install_global_objects(self):
"""
根据[GLOBAL_OBJECTS]中的配置，向servos模块中注入对象。
其他模块可以直接使用import来获取。例如：
from servos import test_obj
"""
import servos
for k, v in settings.GLOBAL_OBJECTS.items():
setattr(servos, k, import_attr(v))
def call(sender, topic, *args, **kwargs):
"""
Invoke receiver functions according topic, it'll invoke receiver functions one by one,
and it'll not return anything, so if you want to return a value, you should
use get function.
"""
if topic not in _receivers:
return NoneValue
items = _receivers[topic]
def _cmp(x, y):
return cmp(x[0], y[0])
items.sort(_cmp)
i = 0
while i < len(items):
nice, f = items[i]
i = i + 1
_f = f['func']
if not _f:
try:
_f = import_attr(f['func_name'])
except (ImportError, AttributeError):
logging.error("Can't import function %s" % f['func_name'])
raise
f['func'] = _f
if callable(_f):
kw = kwargs.copy()
if not _test(kw, f):
continue
try:
_f(sender, *args, **kw)
except:
func = _f.__module__ + '.' + _f.__name__
logging.exception(
'Calling dispatch point [%s] %s(%r, %r) error!' % (topic, func, args, kw))
raise
else:
raise Exception(
"Dispatch point [%s] %r can't been invoked" % (topic, _f))
def get(sender, topic, *args, **kwargs):
"""
Invoke receiver functions according topic, it'll invoke receiver functions one by one,
and if one receiver function return non-None value, it'll return it and break
the loop.
"""
if topic not in _receivers:
return NoneValue
items = _receivers[topic]
def _cmp(x, y):
return cmp(x[0], y[0])
items.sort(_cmp)
for i in range(len(items)):
nice, f = items[i]
_f = f['func']
if not _f:
try:
_f = import_attr(f['func_name'])
except ImportError:
logging.error("Can't import function %s" % f['func_name'])
raise
f['func'] = _f
if callable(_f):
if not _test(kwargs, f):
continue
try:
v = _f(sender, *args, **kwargs)
except:
func = _f.__module__ + '.' + _f.__name__
logging.exception(
'Calling dispatch point [%s] %s(%r,%r) error!' % (topic, func, args, kwargs))
raise
if v is not None:
return v
else:
raise "Dispatch point [%s] %r can't been invoked" % (topic, _f)
def __setitem__(self, name, value):
if isinstance(value, (str, unicode)):
value = import_attr(value)
self.__objects[name] = value
def set_log(self):
s = self.settings
def _get_level(level):
return getattr(logging, level.upper())
# get basic configuration
config = {}
for k, v in s.LOG.items():
if k in ['format', 'datefmt', 'filename', 'filemode']:
config[k] = v
if s.get_var('LOG/level'):
config['level'] = _get_level(s.get_var('LOG/level'))
logging.basicConfig(**config)
if config.get('filename'):
Handler = 'logging.FileHandler'
if config.get('filemode'):
_args = (config.get('filename'), config.get('filemode'))
else:
_args = (config.get('filename'), )
else:
Handler = 'logging.StreamHandler'
_args = ()
# process formatters
formatters = {}
for f, v in s.get_var('LOG.Formatters', {}).items():
formatters[f] = logging.Formatter(v)
# process handlers
handlers = {}
for h, v in s.get_var('LOG.Handlers', {}).items():
handler_cls = v.get('class', Handler)
handler_args = v.get('args', _args)
handler = import_attr(handler_cls)(*handler_args)
if v.get('level'):
handler.setLevel(_get_level(v.get('level')))
format = v.get('format')
if format in formatters:
handler.setFormatter(formatters[format])
elif format:
fmt = logging.Formatter(format)
handler.setFormatter(fmt)
handlers[h] = handler
# process loggers
for logger_name, v in s.get_var('LOG.Loggers', {}).items():
if logger_name == 'ROOT':
log = logging.getLogger('')
else:
log = logging.getLogger(logger_name)
if v.get('level'):
log.setLevel(_get_level(v.get('level')))
if 'propagate' in v:
log.propagate = v.get('propagate')
if 'handlers' in v:
for h in v['handlers']:
if h in handlers:
log.addHandler(handlers[h])
else:
raise ServosError("Log Handler %s is not defined yet!")
elif 'format' in v:
if v['format'] not in formatters:
fmt = logging.Formatter(v['format'])
else:
fmt = formatters[v['format']]
_handler = import_attr(Handler)(*_args)
_handler.setFormatter(fmt)
log.addHandler(_handler)