def create_output(self):
_id = get_uuid()[:6]
self.output('upload', '', {'output':'<div id="upload_%s"><input type="file" name="file" data-url="/upload?path=%s"></input></div>' % (_id, self.command['cwd'].rstrip('>')),
'raw':True,
'eid':_id,
'id':self.command['id']})
self.status = 1
def p():
if len(self._cmd_args) > 1:
filename = os.path.join(self.command['cwd'].rstrip('>'),
self._cmd_args[1])
if not os.path.exists(filename):
self.output('err',
'filename %s is not existed!' % filename)
return
try:
flag = can_download(filename)
if not flag:
self.output(
'err',
"You have no rights to download %s." % filename)
return
except Exception as e:
self.output('err', str(e))
return
token = get_uuid()
#todo check the right of the file
url = '/download?token=' + token
download_tokens[token] = filename
self.output('download', url)
else:
self.output('err',
'You should provide filename paramter first.')
def set_lock(key, value=None, expiry_time=60):
"""Force to set a distribute lock"""
from uliweb.utils.common import get_uuid
redis = get_redis()
value = value or get_uuid()
return redis.set(key, value, ex=expiry_time, xx=True)
def set_lock(key, value=None, expiry_time=60):
"""Force to set a distribute lock"""
from uliweb.utils.common import get_uuid
redis = get_redis()
value = value or get_uuid()
return redis.set(key, value, ex=expiry_time, xx=True)
def p():
cur_path = self.command['cwd'].rstrip('>')
def iter_file():
if len(self._cmd_args) > 1:
for p in self._cmd_args:
for x in iglob(os.path.join(cur_path, p)):
yield x
else:
for x in iglob(os.path.join(cur_path, '*.*')):
yield x
for f in iter_file():
if not os.path.exists(f):
continue
#test is the file is an image
if not test_image(f, strong=True):
continue
try:
flag = can_download(f)
if not flag:
self.output('err', 'You have no rights to view the image file %s.' % f)
continue
except Exception as e:
self.output('err', str(e))
continue
token = get_uuid()
#todo check the right of the file
url = '/images?token=' + token
images_tokens[token] = f
self.output('data', '', {'output':'<img src="/image?token=%s" title="%s"/>'%(token, f),
'raw':True,
'id':self.command['id']}
)
def on_login(self, data):
from uliweb.utils.common import get_uuid
from uliweb import settings
if data['user'] == settings.WSHELL.user and data['password'] == settings.WSHELL.password:
token = get_uuid()
else:
token = False
self.emit('logined', {'output':os.getcwd(), 'token':token, 'id':data['id']})
def save(self, model_name):
import json as JSON
from uliweb.utils.common import get_uuid
column_name = request.GET.get('column_name')
column = JSON.loads(request.POST[column_name])
uuid = request.GET.get('uuid')
action = request.GET.get('action')
obj = self._get_model(model_name, uuid)
old_column = getattr(obj, column_name)
list_columns = column_name in ('fields', 'indexes', 'extension_fields',
'extension_indexes')
if list_columns:
old_column = eval(old_column or '[]')
index = -1
if action in ('edit', 'delete'):
for x in range(len(old_column)):
if old_column[x]['name'] == column['name']:
index = x
break
if index >= 0:
reserved = old_column[index].pop('_reserved', False)
else:
reserved = None
if action in ('add', 'delete') or (index>=0 and old_column[index] != column):
#if not published, then directly use current record
if obj.status == '1':
data = obj.to_dict()
data.pop('id')
data.pop('create_time')
data['status'] = '0'
obj = self.model_his(**data)
obj.uuid = get_uuid()[:6]
if list_columns:
if action == 'add':
old_column.append(column)
elif action == 'edit':
column['_reserved'] = reserved
old_column[index] = column
else:
del old_column[index]
else:
old_column = column
setattr(obj, column_name, old_column)
obj.save(version=True)
uuid = obj.uuid
return json({'success':True, 'message':'Success!', 'data':{'uuid':uuid}})
def on_login(self, data):
from uliweb.utils.common import get_uuid
from uliweb import settings
if data['user'] == settings.WSHELL.user and data['password'] == settings.WSHELL.password:
token = get_uuid()
else:
token = False
path = self._get_login_path()
authenticated[data['id']] = token
self.emit('logined', {'output':path+'>', 'token':token, 'id':data['id']})
def on_login(self, data):
from uliweb.utils.common import get_uuid
from uliweb import settings, application
if data['user'] == settings.WSHELL.user and data['password'] == settings.WSHELL.password:
token = get_uuid()
else:
token = False
os.environ['PROJECT'] = application.project_dir
path = os.path.expandvars(settings.WSHELL.login_path)
self.emit('logined', {'output':path, 'token':token, 'id':data['id']})
def create_output(self):
_id = get_uuid()[:6]
self.output(
'upload', '', {
'output':
'<div id="upload_%s"><input type="file" name="file" data-url="/upload?path=%s"></input></div>'
% (_id, self.command['cwd'].rstrip('>')),
'raw':
True,
'eid':
_id,
'id':
self.command['id']
})
self.status = 1
def on_login(self, data):
from uliweb.utils.common import get_uuid
from uliweb import settings
if data['user'] == settings.WSHELL.user and data[
'password'] == settings.WSHELL.password:
token = get_uuid()
else:
token = False
path = self._get_login_path()
authenticated[data['id']] = token
self.emit('logined', {
'output': path + '>',
'token': token,
'id': data['id']
})
def p():
cur_path = self.command['cwd'].rstrip('>')
def iter_file():
if len(self._cmd_args) > 1:
for p in self._cmd_args:
for x in iglob(os.path.join(cur_path, p)):
yield x
else:
for x in iglob(os.path.join(cur_path, '*.*')):
yield x
for f in iter_file():
if not os.path.exists(f):
continue
#test is the file is an image
if not test_image(f, strong=True):
continue
try:
flag = can_download(f)
if not flag:
self.output(
'err',
'You have no rights to view the image file %s.' %
f)
continue
except Exception as e:
self.output('err', str(e))
continue
token = get_uuid()
#todo check the right of the file
url = '/images?token=' + token
images_tokens[token] = f
self.output(
'data', '', {
'output':
'<img src="/image?token=%s" title="%s"/>' % (token, f),
'raw':
True,
'id':
self.command['id']
})
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 p():
if len(self._cmd_args) > 1:
filename = os.path.join(self.command['cwd'], self._cmd_args[1])
if not os.path.exists(filename):
self.output('err', 'filename %s is not existed!' % filename)
return
try:
flag = can_download(filename)
if not flag:
self.output('err', 'filename %s is not existed!' % filename)
return
except Exception as e:
self.output('err', str(e))
return
token = get_uuid()
#todo check the right of the file
url = '/download?token=' + token
download_tokens[token] = filename
self.output('download', url)
else:
self.output('err', 'You should give filename paramter')
def pre_save(data):
from uliweb.utils.common import get_uuid, import_attr
data['uuid'] = get_uuid()
if not data['display_name']:
data['display_name'] = data['sheet_name']
def __init__(self, command, parameters=None, title=None, timeout=None, max_retry_times=None,
retry_time_interval=None, startup_time=None, base=None, task_id=None,
user_id=None, src_ip=None, version='1.0', correlation=None,
correlation_link=None, parent_task=None,
sync=False, queue=None, **kwargs):
"""
depend is relative task, only when depend task run successfully this task will
be started
sync 表示是否同步执行还是异步, 当True时,执行call_sync时会直接处理
queue使用配置中ASYNC_TASKS_QUEUES的值
"""
from uliweb import settings, request
from uliweb.utils.common import get_uuid
self.name = ''
self.function = ''
self.title = title or command
self.task_id = task_id or get_uuid()
self.parent_task = parent_task
self.timeout = timeout or parse_time(settings.get_var('ASYNC_TASKS/timeout')) #ms
self.max_retry_times = max_retry_times or \
settings.get_var('ASYNC_TASKS/max_retry_times')
self.retry_time_interval = retry_time_interval or parse_time(settings.get_var(
'ASYNC_TASKS/retry_time_interval')) #1m
#add direct queue name, it maybe a list
if isinstance(queue, (tuple, list)):
self.queue = queue
else:
self.queue = settings.ASYNC_TASKS_QUEUES.get(queue or 'default')
self.parameters = parameters or settings.get_var('ASYNC_TASKS/parameters')
self.startup_time = startup_time
self.depend_tasks = []
self.children_count = 0
self.sync = sync
self.task = None
self.tasks = {}
self.version = version
self.base = base or settings.get_var('ASYNC_TASKS/base')
if user_id:
self.user_id = user_id
else:
if request and request.user:
self.user_id = request.user.id
else:
self.user_id = 'SYS'
self.src_ip = src_ip or settings.get_var('PARA/HOST')
self.correlation = correlation
self.correlation_link = correlation_link
self.kwargs = kwargs or {} #external parameters
#process function object
if callable(command):
command = command.__module__ + '.' + command.__name__
self.name = command
if not command:
self.name = ''
self.function = ''
elif isinstance(command, dict):
self.name = command.get('cmd_name', self.name)
if self.name:
s = settings.get_var('ASYNC_TASKS_COMMANDS/%s' % self.name)
if s:
self._set_command(s)
self._set_command(command)
elif isinstance(command, (str, unicode)):
if '.' not in command: #guess it as command name
self.name = command
s = settings.get_var('ASYNC_TASKS_COMMANDS/%s' % self.name)
if s:
self._set_command(s)
else:
raise ErrorWrongSettingEntry(self.name)
else:
self.function = command
self.name = command
else:
raise ErrorWrongCommand(command)
class Form(object):
__metaclass__ = FormMetaclass
layout_class = BootstrapLayout
layout = None
layout_class_args = {}
fieldset = False
form_action = ''
form_method = 'POST'
form_buttons = None
form_title = None
form_class = None
form_id = 'form_' + get_uuid()[:5]
rules = {}
front_rules = {'rules': {}, 'messages': {}}
def __init__(self,
action=None,
method=None,
buttons=None,
validators=None,
html_attrs=None,
data=None,
errors=None,
idtype='name',
title='',
vars=None,
layout=None,
id=None,
_class='',
**kwargs):
self.form_action = action or self.form_action or request_url()
self.form_method = method or self.form_method
self.form_title = title or self.form_title
self.form_class = _class or self.form_class
self.kwargs = kwargs
buttons = buttons or self.form_buttons or [
str(
Button(value=_('Submit'),
_class="btn btn-primary",
name="submit",
type="submit"))
]
if buttons:
if isinstance(buttons, (tuple, list)):
self._buttons = list(buttons)
else:
self._buttons = [buttons]
self.validators = validators or []
self.html_attrs = html_attrs or {}
if '_class' in self.html_attrs:
self.html_attrs['class'] = self.html_attrs.pop('_class')
self.idtype = idtype
self.layout = layout or self.layout
self.vars = vars
for name, obj in self.fields_list:
obj.idtype = self.idtype
if self.form_class:
self.html_attrs[
'class'] = self.form_class # + ' ' + DEFAULT_FORM_CLASS
if 'class' not in self.html_attrs:
self.html_attrs['class'] = ''
self.form_class = self.html_attrs.get('class')
self.form_id = id or self.html_attrs.get('id') or self.form_id
self.bind(data or {}, errors or {})
self.__init_validators()
self.ok = True
@classmethod
def add_field(cls, field_name, field, attribute=False):
if isinstance(field, BaseField):
check_reserved_word(field_name)
cls.fields[field_name] = field
rules = cls.rules.get(field_name)
if rules:
field.rules.update(rules)
field.__property_config__(cls, field_name)
if attribute:
setattr(cls, field_name, field)
cls.fields_list.append((field_name, field))
def __init_validators(self):
for k, obj in self.fields.items():
func = getattr(self, 'validate_%s' % obj.field_name, None)
if func and callable(func):
obj.validators.insert(0, func)
func = getattr(self, 'form_validate', None)
if func and callable(func):
self.validators.append(func)
def validate(self, *data):
old_data = self.data.copy()
all_data = {}
for k, v in self.fields.items():
#skip static field
if not v.static:
v.parse_data(data, all_data)
errors = D({})
new_data = {}
#gather all fields
for field_name, field in self.fields.items():
new_data[field_name] = field.get_data(all_data)
#validate and gather the result
# result = D({})
result = D(new_data.copy())
for field_name, field in self.fields.items():
flag, value = field.validate(new_data[field_name], result)
if not flag:
if isinstance(value, dict):
errors.update(value)
else:
errors[field_name] = value
else:
result[field_name] = value
if not errors and self.validators:
#validate global
for v in self.validators:
r = v(result)
if r:
errors.update(r)
if errors:
self.ok = False
self.errors = errors
self.data = new_data
else:
self.ok = True
self.errors = {}
self.data = result
#the data of static field will be put into parsed data
for k, v in self.fields.items():
if v.static and k in old_data:
self.data[k] = old_data[k]
return self.ok
def __str__(self):
return self.html()
def _repr_html_(self):
return self.html()
@property
def form_begin(self):
args = self.html_attrs.copy()
args['action'] = self.form_action
args['method'] = self.form_method
for field_name, field in self.fields.items():
if isinstance(field, FileField):
args['enctype'] = "multipart/form-data"
break
return begin_tag('form', **args)
@property
def form_end(self):
return '</form>\n'
def get_buttons(self):
return self._buttons
def bind(self, data=None, errors=None):
if data is not None:
self.data = data
if errors is not None:
self.errors = errors
def html(self):
cls = get_form_layout_class(self.layout_class)
layout = cls(self, self.layout, **self.layout_class_args)
pre_html = self.pre_html() if hasattr(self, 'pre_html') else ''
body = layout.html()
post_html = self.post_html() if hasattr(self, 'post_html') else ''
return ''.join([str(x) for x in [pre_html, body, post_html]])
@property
def build(self):
cls = get_form_layout_class(self.layout_class)
layout = cls(self, self.layout, **self.layout_class_args)
result = FormBuild()
result.pre_html = self.pre_html() if hasattr(self, 'pre_html') else ''
result.begin = layout.begin()
result.body = layout.hiddens() + layout.body()
result.buttons = layout.buttons()
result.buttons_line = layout.buttons_line()
result.end = layout.end()
result.post_html = self.post_html() if hasattr(self,
'post_html') else ''
return result
def get_json(self):
return {
'fields': self.get_fields(),
'layout': self.get_layout(),
'data': self.data,
'rules': self.front_rules['rules'],
'messages': self.front_rules['messages'],
}
def get_fields(self):
s = []
for f in self.fields_list:
f[1].name = f[0]
d = f[1].to_json(self.data.get(f[0]))
s.append(d)
return s
def get_layout(self):
if self.layout:
return self.layout
layout = []
for x in self.fields_list:
layout.append(x[0])
layout = [tuple(layout)]
return layout
def call(args, options, global_options):
global jobs, jobs_time
from uliweb import settings
from uliweb.utils.common import get_uuid
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
log.info('=============================')
log.info(' Cron Job Daemon Starting')
log.info('=============================')
log.info('Daemon process %d' % os.getpid())
init()
if len(jobs_time) == 0:
log.info("Job queue is empty")
else:
log.info("Job queue size is {}".format(len(jobs_time)))
breakout = Breakout('cron_refresh')
if hasattr(options, 'lock_timeout'):
timeout = options.lock_timeout
else:
timeout = settings.get_var('CRON/lock_timeout', 60)
if hasattr(options, 'debug'):
debug = options.debug
else:
debug = False
key = 'cron:cron_instance'
value = get_uuid()
log.info('Key=[{}/{}], lock_timeout={}, debug={}'.format(key, value, timeout, debug))
spawn(continue_lock(key, value, timeout, debug))
while not is_exit:
try:
waiting_lock(key, value, timeout, debug)
if jobs_time:
with breakout:
_time, _id = jobs_time[0]
job = jobs[_id]
now = date.now()
t = _time - time.mktime(now.timetuple())
if t <= 0:
#产生一个新的时间
jobs_time.pop(0)
_t = get_exe_time(job)
bisect.insort(jobs_time, (_t, _id))
#启动作业
start_job(job, now)
else:
log.info(u"Sleep {0} seconds will start job [{2} -- {1}] at {3}".format(t,
job.time, job.title, now+datetime.timedelta(seconds=t)))
else:
t = 60
time.sleep(t)
except BreakoutException as e:
init()
def call(args, options, global_options):
global jobs, jobs_time
from uliweb import settings
from uliweb.utils.common import get_uuid
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
log.info('=============================')
log.info(' Cron Job Daemon Starting')
log.info('=============================')
log.info('Daemon process %d' % os.getpid())
init()
if len(jobs_time) == 0:
log.info("Job queue is empty")
else:
log.info("Job queue size is {}".format(len(jobs_time)))
breakout = Breakout('cron_refresh')
if hasattr(options, 'lock_timeout'):
timeout = options.lock_timeout
else:
timeout = settings.get_var('CRON/lock_timeout', 60)
if hasattr(options, 'debug'):
debug = options.debug
else:
debug = False
key = 'cron:cron_instance'
value = get_uuid()
log.info('Key=[{}/{}], lock_timeout={}, debug={}'.format(
key, value, timeout, debug))
spawn(continue_lock(key, value, timeout, debug))
while not is_exit:
try:
waiting_lock(key, value, timeout, debug)
if jobs_time:
with breakout:
_time, _id = jobs_time[0]
job = jobs[_id]
now = date.now()
t = _time - time.mktime(now.timetuple())
if t <= 0:
#产生一个新的时间
jobs_time.pop(0)
_t = get_exe_time(job)
bisect.insort(jobs_time, (_t, _id))
#启动作业
start_job(job, now)
else:
log.info(
u"Sleep {0} seconds will start job [{2} -- {1}] at {3}"
.format(t, job.time, job.title,
now + datetime.timedelta(seconds=t)))
else:
t = 60
time.sleep(t)
except BreakoutException as e:
init()
