def function(fname, *args, **kwargs):
func = settings.get_var('FUNCTIONS/'+fname)
if func:
if args or kwargs:
return import_attr(func)(*args, **kwargs)
else:
return import_attr(func)
else:
raise UliwebError("Can't find the function [%s] in settings" % fname)
def function(fname, *args, **kwargs):
func = settings.get_var('FUNCTIONS/'+fname)
if func:
if args or kwargs:
return import_attr(func)(*args, **kwargs)
else:
return import_attr(func)
else:
raise UliwebError("Can't find the function [%s] in settings" % fname)
def has_role(user, *roles, **kwargs):
"""
Judge is the user belongs to the role, and if does, then return the role object
if not then return False. kwargs will be passed to role_func.
"""
Role = get_model("role")
if isinstance(user, (unicode, str)):
User = get_model("user")
user = User.get(User.c.username == user)
for role in roles:
if isinstance(role, (str, unicode)):
role = Role.get(Role.c.name == role)
if not role:
continue
name = role.name
func = __role_funcs__.get(name, None)
if func:
if isinstance(func, (unicode, str)):
func = import_attr(func)
assert callable(func)
para = kwargs.copy()
para["user"] = user
flag = call_func(func, para)
if flag:
return role
flag = role.users.has(user)
if flag:
return role
return False
def dispatch_event(self, event_type, **attrs):
if isinstance(event_type, Event):
e = event_type
else:
e = Event(event_type, self)
if event_type in self._events.keys():
for k, v in attrs.iteritems():
setattr(e, k, v)
listeners = self._events[e.type]
for listener in listeners:
_f = listener['func']
if not _f:
try:
_f = import_attr(listener['func_name'])
except (ImportError, AttributeError) as e:
LOG.error("Can't import function %s" % listener['func_name'])
raise ImportError
listener['func'] = _f
if callable(_f):
try:
_f(e)
except:
func = _f.__module__ + '.' + _f.__name__
LOG.exception('Calling dispatch event [%s] %s() error!' % (event_type, func))
raise
def startup_installed(sender):
from uliweb import settings
import uliweb.form.uliform as form
from uliweb.utils.common import import_attr
for k, v in settings.get_var('FORM_FIELDS_MAP', {}).items():
form.fields_mapping[k] = import_attr(v)
def linci_artifact_types():
for id,sort_num,type_class in settings.LINCI.artifact_type:
if type_class:
type_class = import_attr(type_class)
else:
type_class = None
yield id,sort_num,type_class
def _validate(menu, context, validators=None):
#validate permission
validators = validators or []
check = menu.get('check')
if check and not isinstance(check, (list, tuple)):
check = [check]
else:
check = []
validators = validators + check
if validators:
flag = False
for v in validators:
if not v: continue
if isinstance(v, string_types):
func = import_attr(v)
else:
func = v
flag = func(menu, context)
if flag:
flag = True
break
else:
flag = True
return flag
def install_middlewares(self):
#middleware process
#middleware can be defined as
#middleware_name = middleware_class_path[, order]
#middleware_name = <empty> will be skip
middlewares = []
index = {}
for middleware_name, v in settings.get('MIDDLEWARES', {}).iteritems():
#process duplication of middleware, later will replace former
if middleware_name in index:
middlewares.pop(middleware_name)
if not v:
continue
order = None
if isinstance(v, (list, tuple)):
if len(v) > 2:
raise UliwebError('Middleware %s difinition is not right' % middleware_name)
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)
middlewares.append((order, cls))
#remember the middleware index, so that can be used for easily remove
index[middleware_name] = len(middlewares) - 1
middlewares.sort(cmp=lambda x, y: cmp(x[0], y[0]))
return [x[1] for x in middlewares]
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 UliwebError('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 do(self, command):
from uliweb import settings
cmd = command['cmd']
_id = command['id']
last_process = self.shells.get(_id)
if last_process and last_process.process and last_process.process.poll(
) is None:
process = last_process.process
self.log('Using last process %r' % process)
process.stdin.write(cmd + '\n')
process.stdin.flush()
else:
cmd_args = shlex.split(cmd)
cmd_path = settings.COMMANDS.get(cmd_args[0])
if cmd_path:
cmd_cls = import_attr(cmd_path)
else:
cmd_cls = Command
p = cmd_cls(cmd_args, command, self)
self.shells[_id] = p
#p.process may be None, so that it can do other thing more than commad line
if p.process and p.process.poll() is None:
p.output('cwd', self.safe_encode(p.cwd))
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 not topic in _receivers:
return
items = _receivers[topic]
items.sort()
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:
logging.exception('Calling dispatch point [%s] error!' % topic)
raise
if v is not None:
return v
else:
raise "Dispatch point [%s] can't been invoked" % topic
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 UliwebError('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 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 not topic in _receivers:
return
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, AttributeError) as e:
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 _validate(menu, context, validators=None):
from uliweb.utils.common import import_attr
#validate permission
validators = validators or []
check = menu.get('check')
if check and not isinstance(check, (list, tuple)):
check = [check]
else:
check = []
validators = validators + check
if validators:
flag = False
for v in validators:
if not v: continue
if isinstance(v, (str, unicode)):
func = import_attr(v)
else:
func = v
flag = func(menu, context)
if flag:
flag = True
break
else:
flag = True
return flag
def authenticate(username, password, auth_type=None):
from uliweb import settings
auth_type = auth_type or settings.AUTH.AUTH_DEFAULT_TYPE
err_msg = ''
if not isinstance(auth_type, (list, tuple)):
auth_type = [auth_type]
for t in auth_type:
if t in settings.AUTH_CONFIG:
func_path = settings.AUTH_CONFIG[t].get('authenticate')
if func_path:
func = import_attr(func_path)
f, d = func(username, password)
if f:
log.info("login successfully, auth_type: %s"%(t))
return f, d
else:
log.error("fail to login, auth_type: %s, err: %s"%(t,d))
err_msg = d
else:
log.error("auth_type %s not in config"%(t))
return False, {'username':err_msg}
def install_template_processors(self):
for v in settings.TEMPLATE_PROCESSORS.values():
for ext in v.get('file_exts', []):
self.template_processors[ext] = {
'func': import_attr(v['processor']),
'args': v.get('args', {})
}
def has_role(user, *roles, **kwargs):
"""
Judge is the user belongs to the role, and if does, then return the role object
if not then return False. kwargs will be passed to role_func.
"""
Role = get_model('role')
if isinstance(user, (unicode, str)):
User = get_model('user')
user = User.get(User.c.username == user)
for role in roles:
if isinstance(role, (str, unicode)):
role = Role.get(Role.c.name == role)
if not role:
return False
name = role.name
func = __role_funcs__.get(name, None)
if func:
if isinstance(func, (unicode, str)):
func = import_attr(func)
assert callable(func)
para = kwargs.copy()
para['user'] = user
flag = call_func(func, para)
if flag:
return role
flag = role.users.has(user)
if flag:
return role
return False
def authenticate(username, password, auth_type=None):
from uliweb import settings
auth_type = auth_type or settings.AUTH.AUTH_DEFAULT_TYPE
err_msg = ''
if not isinstance(auth_type, (list, tuple)):
auth_type = [auth_type]
for t in auth_type:
if t in settings.AUTH_CONFIG:
func_path = settings.AUTH_CONFIG[t].get('authenticate')
if func_path:
func = import_attr(func_path)
f, d = func(username, password)
if f:
log.info("login successfully, auth_type: %s" % (t))
return f, d
else:
log.error("fail to login, auth_type: %s, err: %s" % (t, d))
err_msg = d
else:
log.error("auth_type %s not in config" % (t))
return False, {'username': err_msg}
def get_cache(**kwargs):
from uliweb import settings
from weto.cache import Cache
from uliweb.utils.common import import_attr, application_path
serial_cls_path = settings.get_var('CACHE/serial_cls')
if serial_cls_path:
serial_cls = import_attr(serial_cls_path)
if settings.GLOBAL.PICKLE_PROTOCAL_LEVEL is not None:
serial_cls.protocal_level = settings.GLOBAL.PICKLE_PROTOCAL_LEVEL
else:
serial_cls = None
options = dict(settings.get_var('CACHE_STORAGE', {}))
options['data_dir'] = application_path(options['data_dir'])
args = {
'storage_type': settings.get_var('CACHE/type'),
'options': options,
'expiry_time': settings.get_var('CACHE/expiretime'),
'serial_cls': serial_cls
}
args.update(kwargs)
cache = Cache(**args)
return cache
def get_session(key=None):
options = dict(settings.get('SESSION_STORAGE', {}))
options['data_dir'] = application_path(options['data_dir'])
if 'url' not in options:
_url = (settings.get_var('ORM/CONNECTION', '') or settings.get_var(
'ORM/CONNECTIONS', {}).get('default', {}).get('CONNECTION', ''))
if _url:
options['url'] = _url
#process Session options
session_storage_type = settings.SESSION.type
Session.force = settings.SESSION.force
serial_cls_path = settings.SESSION.serial_cls
if serial_cls_path:
serial_cls = import_attr(serial_cls_path)
else:
serial_cls = None
session = Session(key,
storage_type=session_storage_type,
options=options,
expiry_time=settings.SESSION.timeout,
serial_cls=serial_cls)
return session
def authenticate(username, password, auth_type=None):
from uliweb import settings, request
auth_type = auth_type or settings.AUTH.AUTH_DEFAULT_TYPE
errors = {}
if not isinstance(auth_type, (list, tuple)):
auth_type = [auth_type]
ip = request.environ['REMOTE_ADDR']
for t in auth_type:
if t in settings.AUTH_CONFIG:
func_path = settings.AUTH_CONFIG[t].get('authenticate')
if func_path:
func = import_attr(func_path)
f, d = func(username, password)
if f:
if hasattr(d,"locked") and d.locked:
log.error("'%s' fail to login, err: user '%s' is locked"%(ip, d))
return False, {'username': _('"{}" is locked!').format(username)}
if hasattr(d,"deleted") and d.deleted:
log.error("'%s' fail to login, err: user '%s' is deleted"%(ip, d))
return False, {'username': _('"{}" is deleted!').format(username)}
log.info("'%s' login successfully as user '%s', auth_type: %s"%(ip, username, t))
return f, d
else:
log.error("'%s' fail to login, auth_type: %s, err: %s"%(ip, t, d))
errors = d
else:
log.error("auth_type %s not in config"%(t))
return False, errors
def startup_installed(sender):
from uliweb import settings
import uliweb.form.uliform as form
from uliweb.utils.common import import_attr
for k, v in settings.get_var('FORM_FIELDS_MAP', {}).items():
form.fields_mapping[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 not topic in _receivers:
return
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, AttributeError) as e:
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 __init__(self,
default_filename_converter_cls=UUIDFilenameConverter,
config=None):
self.config = config or self.default_config
for k, v in self.options.items():
item, default = v
#if there is no '/' in option, then combine config with option
#else assume the option is just like 'SECTION/OPTION', then skip it
if '/' not in item:
item = self.config + '/' + item
value = settings.get_var(item, default)
setattr(self, k, value)
if self.x_sendfile and not self.x_header_name:
if self.x_sendfile == 'nginx':
self.x_header_name = 'X-Accel-Redirect'
elif self.x_sendfile == 'apache':
self.x_header_name = 'X-Sendfile'
else:
raise Exception(
"X_HEADER can't be None, or X_SENDFILE is not supprted")
if isinstance(self._filename_converter, (str, unicode)):
self._filename_converter_cls = import_attr(
self._filename_converter)
else:
self._filename_converter_cls = self._filename_converter or default_filename_converter_cls
def run(self):
"""
直接运行当前的命令
"""
f = import_attr(self.function)
ret = f(**self.parameters)
return ret
def after_init_apps(sender):
from uliweb import orm
from uliweb.utils.common import import_attr
from uliweb.core.SimpleFrame import __app_alias__
orm.set_debug_query(settings.get_var('ORM/DEBUG_LOG'))
orm.set_auto_create(settings.get_var('ORM/AUTO_CREATE'))
orm.set_pk_type(settings.get_var('ORM/PK_TYPE'))
orm.set_auto_set_model(False)
orm.set_lazy_model_init(True)
orm.set_check_max_length(settings.get_var('ORM/CHECK_MAX_LENGTH'))
orm.set_nullable(settings.get_var('ORM/NULLABLE'))
orm.set_server_default(settings.get_var('ORM/SERVER_DEFAULT'))
orm.set_manytomany_index_reverse(settings.get_var('ORM/MANYTOMANY_INDEX_REVERSE'))
convert_path = settings.get_var('ORM/TABLENAME_CONVERTER')
convert = import_attr(convert_path) if convert_path else None
orm.set_tablename_converter(convert)
#judge if transaction middle has not install then set
#AUTO_DOTRANSACTION is False
if 'transaction' in settings.MIDDLEWARES:
orm.set_auto_dotransaction(False)
else:
orm.set_auto_dotransaction(settings.get_var('ORM/AUTO_DOTRANSACTION'))
d = {'connection_string':settings.get_var('ORM/CONNECTION'),
'connection_type':settings.get_var('ORM/CONNECTION_TYPE'),
'debug_log':settings.get_var('ORM/DEBUG_LOG'),
'connection_args':settings.get_var('ORM/CONNECTION_ARGS'),
'strategy':settings.get_var('ORM/STRATEGY'),
}
orm.engine_manager.add('default', d)
for name, d in settings.get_var('ORM/CONNECTIONS').items():
x = {'connection_string':d.get('CONNECTION', ''),
'debug_log':d.get('DEBUG_LOG', None),
'connection_args':d.get('CONNECTION_ARGS', {}),
'strategy':d.get('STRATEGY', 'threadlocal'),
'connection_type':d.get('CONNECTION_TYPE', 'long')
}
orm.engine_manager.add(name, x)
if 'MODELS' in settings:
for name, model_path in settings.MODELS.items():
if not model_path: continue
if isinstance(model_path, (str, unicode)):
path = model_path
engine_name = 'default'
else:
path, engine_name = model_path
for k, v in __app_alias__.iteritems():
if path.startswith(k):
path = v + path[len(k):]
break
orm.set_model(path, name, engine_name=engine_name)
if 'MODELS_CONFIG' in settings:
for name, v in settings.MODELS_CONFIG.items():
orm.set_model_config(name, v)
def __getattr__(self, name):
if name in self.__objects:
return self.__objects[name]
if name not in settings[self.__section]:
raise UliwebError("Object %s is not existed!" % name)
obj = import_attr(settings[self.__section].get(name))
self.__objects[name] = obj
return obj
def __getattr__(self, name):
if name in self.__objects:
return self.__objects[name]
if name not in settings[self.__section]:
raise UliwebError("Object %s is not existed!" % name)
obj = import_attr(settings[self.__section].get(name))
self.__objects[name] = obj
return obj
def __getattr__(self, name):
if name in self.__decorators__:
return self.__decorators__[name]
if name not in conf.settings.DECORATORS:
raise Exception, "decorator %s is not existed!" % name
func = import_attr(conf.settings.DECORATORS.get(name))
self.__decorators__[name] = func
return func
def __getattr__(self, name):
if name in self.__functions__:
return self.__functions__[name]
if name not in conf.settings.FUNCTIONS:
raise Exception, "function %s is not existed!" % name
func = import_attr(conf.settings.FUNCTIONS.get(name))
self.__functions__[name] = func
return func
def install_global_objects(self):
"""
Process [GLOBAL_OBJECTS], and inject all object to uliweb module, so
user can import from uliweb
"""
import uliweb
for k, v in settings.GLOBAL_OBJECTS.items():
setattr(uliweb, k, import_attr(v))
def __getattr__(self, name):
if name in self.__functions__:
return self.__functions__[name]
if name not in settings.FUNCTIONS:
raise UliwebError("function %s is not existed!" % name)
func = import_attr(settings.FUNCTIONS.get(name))
self.__functions__[name] = func
return func
def install_global_objects(self):
"""
Process [GLOBAL_OBJECTS], and inject all object to uliweb module, so
user can import from uliweb
"""
import uliweb
for k, v in settings.GLOBAL_OBJECTS.items():
setattr(uliweb, k, import_attr(v))
def print_menu_html(name, type='side'):
from uliweb import settings
if type == 'side':
_menu = settings.MENUS_CONFIG.menu_render or default_menu
elif type == 'main':
_menu = settings.MENUS_CONFIG.menu_render or default_navigation
print(import_attr(_menu)(name=name))
def __getattr__(self, name):
if name in self.__decorators__:
return self.__decorators__[name]
if name not in settings.DECORATORS:
raise UliwebError("decorator %s is not existed!" % name)
func = import_attr(settings.DECORATORS.get(name))
self.__decorators__[name] = func
return func
def install_template_loader(self, dirs):
Loader = import_attr(settings.get_var('TEMPLATE_PROCESSOR/loader'))
args = settings.get_var('TEMPLATE')
if self.debug:
args['check_modified_time'] = True
args['log'] = log
args['debug'] = settings.get_var('GLOBAL/DEBUG_TEMPLATE', False)
return Loader(dirs, **args)
def create_client(sns_name):
from uliweb import settings
from uliweb.utils.common import import_attr
servers = settings.get_var("Parrot/ServerList")
server = servers[sns_name]
return import_attr(server['info'][1])(
server['client_id'],
server['client_secret'],
server['redirect_uri'])
def install_template_loader(self, dirs):
Loader = import_attr(settings.get_var('TEMPLATE_PROCESSOR/loader'))
args = settings.get_var('TEMPLATE')
if self.debug:
args['check_modified_time'] = True
args['log'] = log
args['debug'] = settings.get_var('GLOBAL/DEBUG_TEMPLATE', False)
return Loader(dirs, **args)
def soap(self):
from pysimplesoap.server import SoapDispatcher
import uliweb.contrib.soap as soap
from uliweb.utils.common import import_attr
from uliweb import application as app, response, url_for
from functools import partial
global __soap_dispatcher__
if not __soap_dispatcher__:
location = "%s://%s%s" % (
request.environ['wsgi.url_scheme'],
request.environ['HTTP_HOST'],
request.path)
namespace = functions.get_var(self.config).get('namespace') or location
documentation = functions.get_var(self.config).get('documentation')
dispatcher = SoapDispatcher(
name = functions.get_var(self.config).get('name'),
location = location,
action = '', # SOAPAction
namespace = namespace,
prefix=functions.get_var(self.config).get('prefix'),
documentation = documentation,
exception_handler = partial(exception_handler, response=response),
ns = True)
for name, (func, returns, args, doc) in soap.__soap_functions__.get(self.config, {}).items():
if isinstance(func, (str, unicode)):
func = import_attr(func)
dispatcher.register_function(name, func, returns, args, doc)
else:
dispatcher = __soap_dispatcher__
if 'wsdl' in request.GET:
# Return Web Service Description
response.headers['Content-Type'] = 'text/xml'
response.write(dispatcher.wsdl())
return response
elif request.method == 'POST':
def _call(func, args):
rule = SimpleRule()
rule.endpoint = func
mod, handler_cls, handler = app.prepare_request(request, rule)
result = app.call_view(mod, handler_cls, handler, request, response, _wrap_result, kwargs=args)
r = _fix_soap_datatype(result)
return r
# Process normal Soap Operation
response.headers['Content-Type'] = 'text/xml'
log.debug("---request message---")
log.debug(request.data)
result = dispatcher.dispatch(request.data, call_function=_call)
log.debug("---response message---")
log.debug(result)
response.write(result)
return response
def menu(name, active='', check=None, id=None, _class=None):
from uliweb import settings
if check and not isinstance(check, (list, tuple)):
check = [check]
else:
check = []
validators = (settings.MENUS_CONFIG.validators or []) + list(check)
_menu = settings.MENUS_CONFIG.menu_render or default_menu
return import_attr(_menu)(name=name, active=active, validators=validators, id=id, _class=_class)
def menu(name, active='', check=None, id=None, _class=None):
from uliweb import settings
if check and not isinstance(check, (list, tuple)):
check = [check]
else:
check = []
validators = (settings.MENUS_CONFIG.validators or []) + list(check)
_menu = settings.MENUS_CONFIG.menu_render or default_menu
return import_attr(_menu)(name=name, active=active, validators=validators, id=id, _class=_class)
def __init__(self, host=None, port=None, user=None, password=None, backend=None):
from uliweb import settings
from uliweb.utils.common import import_attr
self.host = host or (settings and settings.get_var('MAIL/HOST'))
self.port = port or (settings and settings.get_var('MAIL/PORT', 25))
self.user = user or (settings and settings.get_var('MAIL/USER'))
self.password = password or (settings and settings.get_var('MAIL/PASSWORD'))
self.backend = backend or (settings and settings.get_var('MAIL/BACKEND', 'uliweb.mail.backends.smtp'))
cls = import_attr(self.backend + '.MailConnection')
self.con = cls(self)
def __init__(self, host=None, port=None, user=None, password=None, backend=None, sendmail_location=None):
from uliweb import settings
from uliweb.utils.common import import_attr
self.host = host or settings.get_var('MAIL/HOST')
self.port = port or settings.get_var('MAIL/PORT', 25)
self.user = user or settings.get_var('MAIL/USER')
self.password = password or settings.get_var('MAIL/PASSWORD')
self.backend = backend or settings.get_var('MAIL/BACKEND', 'uliweb.mail.backends.smtp')
self.sendmail_location = sendmail_location or settings.get_var('MAIL/SENDMAIL_LOCATION', '/usr/sbin/sendmail')
cls = import_attr(self.backend + '.MailConnection')
self.con = cls(self)
def process_request(self, request):
key = request.cookies.get(SessionCookie.default_cookie_id)
if not key:
key = request.values.get(SessionCookie.default_cookie_id)
serial_cls_path = settings.SESSION.serial_cls
if serial_cls_path:
serial_cls = import_attr(serial_cls_path)
else:
serial_cls = None
session = Session(key, storage_type=self.session_storage_type,
options=self.options, expiry_time=self.timeout, serial_cls=serial_cls)
request.session = session
def pre_save(data):
from uliweb.utils.common import get_uuid, import_attr
from uliweb.contrib.model_config import get_model_fields, get_model_indexes
data['uuid'] = get_uuid()[:6]
if not data['table_name']:
data['table_name'] = data['model_name'].lower()
if not data['display_name']:
data['display_name'] = data['model_name']
#add import basemodel support
if data['basemodel']:
BM = import_attr(data['basemodel'])
data['fields'] = get_model_fields(BM)
data['indexes'] = get_model_indexes(BM)
if data['extension_model']:
EM = import_attr(data['extension_model'])
data['extension_fields'] = get_model_fields(EM)
data['extension_indexes'] = get_model_indexes(EM)
def process_request(self, request):
key = request.cookies.get(SessionCookie.default_cookie_id)
if not key:
key = request.values.get(SessionCookie.default_cookie_id)
serial_cls_path = settings.SESSION.serial_cls
if serial_cls_path:
serial_cls = import_attr(serial_cls_path)
else:
serial_cls = None
session = Session(key, storage_type=self.session_storage_type,
options=self.options, expiry_time=self.timeout, serial_cls=serial_cls)
request.session = session
def get_backend():
global default_fileserving
if default_fileserving:
return default_fileserving
else:
cls = settings.get_var('UPLOAD/BACKEND')
if cls:
default_fileserving = import_attr(cls)()
else:
default_fileserving = FileServing()
return default_fileserving
def get_backend():
global default_fileserving
if default_fileserving:
return default_fileserving
else:
cls = settings.get_var('UPLOAD/BACKEND')
if cls:
default_fileserving = import_attr(cls)()
else:
default_fileserving = FileServing()
return default_fileserving
def after_init_apps(sender):
from uliweb import orm
from uliweb.utils.common import import_attr
from uliweb.core.SimpleFrame import __app_alias__
orm.set_debug_query(settings.get_var('ORM/DEBUG_LOG'))
orm.set_auto_create(settings.get_var('ORM/AUTO_CREATE'))
orm.set_pk_type(settings.get_var('ORM/PK_TYPE'))
orm.set_auto_set_model(False)
orm.set_check_max_length(settings.get_var('ORM/CHECK_MAX_LENGTH'))
convert_path = settings.get_var('ORM/TABLENAME_CONVERTER')
convert = import_attr(convert_path) if convert_path else None
orm.set_tablename_converter(convert)
#judge if transaction middle has not install then set
#AUTO_DOTRANSACTION is False
if 'transaction' in settings.MIDDLEWARES:
orm.set_auto_dotransaction(False)
else:
orm.set_auto_dotransaction(settings.get_var('ORM/AUTO_DOTRANSACTION'))
d = {
'connection_string': settings.get_var('ORM/CONNECTION'),
'connection_type': settings.get_var('ORM/CONNECTION_TYPE'),
'debug_log': settings.get_var('ORM/DEBUG_LOG'),
'connection_args': settings.get_var('ORM/CONNECTION_ARGS'),
'strategy': settings.get_var('ORM/STRATEGY'),
}
orm.engine_manager.add('default', d)
for name, d in settings.get_var('ORM/CONNECTIONS').items():
x = {
'connection_string': d.get('CONNECTION', ''),
'debug_log': d.get('DEBUG_LOG', None),
'connection_args': d.get('CONNECTION_ARGS', {}),
'strategy': d.get('STRATEGY', 'threadlocal'),
'connection_type': d.get('CONNECTION_TYPE', 'long')
}
orm.engine_manager.add(name, x)
if 'MODELS' in settings:
for name, model_path in settings.MODELS.items():
if isinstance(model_path, (str, unicode)):
path = model_path
engine_name = 'default'
else:
path, engine_name = model_path
for k, v in __app_alias__.iteritems():
if path.startswith(k):
path = v + path[len(k):]
break
orm.set_model(path, name, engine_name=engine_name)
def after_init_apps(sender):
global __schemas__, __default_limit__
if 'JSONQL_SCHEMA' in settings:
for name, model_path in settings.JSONQL_SCHEMA.items():
if not model_path: continue
if isinstance(model_path, (str, unicode)):
path = model_path
else:
raise Exception("Schema path should be a string but %r found" % model_path)
__schemas__[name] = import_attr(model_path)
__default_limit__ = settings.JSONQL.get('limit', 10)
def init(self):
global __static_combine__, __static_mapping__
from . import init_static_combine
from uliweb import settings
from uliweb.utils.common import import_attr
if __static_combine__ is None:
func = settings.get_var(
'STATIC_COMBINE_CONFIG/init_static_combine',
init_static_combine)
__static_combine__ = import_attr(func)()
for k, v in __static_combine__.items():
for x in v:
__static_mapping__[x] = k
def get_cipher(key=None):
"""
Get cipher object, and then you can invoke:
des = get_cipher()
d = des.encrpy('Hello')
print des.descrpy(d)
"""
des_func = import_attr(settings.SECRETKEY.CIPHER_CLS)
kwargs = settings.SECRETKEY.CIPHER_ARGS
if not key:
key = functions.get_cipher_key()
cipher = des_func(key, **kwargs)
return cipher
def run(self):
import traceback
Task = functions.get_model('async_Tasks')
try:
self.before()
if not self.func:
self.ret = 'empty'
self.log.debug("Async task {} function is empty".format(self.task_id))
else:
f = import_attr(self.func)
self.log.debug("Run Async task {} function {!r}({!r})".format(
self.task_id, f, self.parameters))
#_args表示位置参数
args = self.parameters.pop('_args', ())
self.ret = f(*args, **self.parameters)
self.log.debug("Execute {!r} with {!r} and the result is {!r}".format(
f, self.parameters, self.ret))
self.on_finish()
self.after()
self.save()
except Exception as e:
type, value, tb = sys.exc_info()
txt = ''.join(traceback.format_exception(type, value, tb))
if self.task.retry_times >= self.task.max_retry_times:
status = FAILED
finished_time = date.now()
startup_time = self.task.startup_time
msg = 'Async task {} reaches max retry times, status changes to FAILED'.format(self.task.task_id)
self.log.info(msg)
else:
status = ERROR
startup_time = (date.now() +
datetime.timedelta(milliseconds=self.task.retry_time_interval*(self.task.retry_times-1)))
finished_time = None
msg = 'Async task {} runs on error, it will startup at {}'.format(self.task.task_id, startup_time)
self.log.info(msg)
self.save(execution_info=txt,
finished_time=finished_time,
startup_time=startup_time,
status=status,
message=msg)
self.log.exception(e)
def get_backend(config=None):
global default_fileserving
if default_fileserving and not config:
return default_fileserving
else:
config = config or 'UPLOAD'
cls = settings.get_var('%s/BACKEND' % config)
if cls:
fileserving = import_attr(cls)(config=config)
else:
fileserving = FileServing(config=config)
if config == 'UPLOAD':
default_fileserving = fileserving
return fileserving
def set_object(model, instance, fields=None, engine_name=None):
"""
Only support simple condition, for example: Model.c.id == n
if not id provided, then use instance.id
"""
from uliweb import settings
if not check_enable():
return
redis = get_redis()
if not redis: return
tablename = model._alias or model.tablename
exclude = []
if not fields:
fields, exclude = get_fields(tablename)
v = instance.dump(fields, exclude=exclude)
info = settings.get_var('OBJCACHE_TABLES/%s' % tablename, {})
if info is None:
return
expire = settings.get_var('OBJCACHE/timeout', 0)
key = 'id'
if info and isinstance(info, dict):
expire = info.get('expire', expire)
key = info.get('key', key)
if '.' in key or key not in model.properties:
_key = import_attr(key)(instance)
else:
_key = getattr(instance, key)
_id = get_id(engine_name or model.get_engine_name(), tablename, _key)
try:
pipe = redis.pipeline()
p = pipe.delete(_id).hmset(_id, v)
expire_msg = ''
if expire:
p = p.expire(_id, expire)
expire_msg = ':expire=%d' % expire
r = p.execute()
log.debug("Saving to cache objcache:set:table=%s:id=[%s]:%s" %
(tablename, _id, expire_msg))
except Exception, e:
log.exception(e)
def __init__(self,
host=None,
port=None,
user=None,
password=None,
backend=None):
from uliweb import settings
from uliweb.utils.common import import_attr
self.host = host or (settings and settings.get_var('MAIL/HOST'))
self.port = port or (settings and settings.get_var('MAIL/PORT', 25))
self.user = user or (settings and settings.get_var('MAIL/USER'))
self.password = password or (settings
and settings.get_var('MAIL/PASSWORD'))
self.backend = backend or (settings and settings.get_var(
'MAIL/BACKEND', 'uliweb.mail.backends.smtp'))
cls = import_attr(self.backend + '.MailConnection')
self.con = cls(self)
