def stop_task(cls, name):
task = Backend('task').find(name)
if not task.is_running():
task.status = Task.STOP
Backend('task').save(task)
return True
return False
def add_user(self, username, email, real_name, password, status='', role='user'):
username, real_name = username.strip(), real_name.strip()
if not re.match(r'^[A-Za-z0-9_]{4,16}$', username):
return {'status' : 'error', 'msg' : 'user name: %s must be the ^[A-Za-z0-9_]{4,16}$ pattern' %(username)}
if not re.match(r'^[A-Za-z0-9_ ]{4,16}$', real_name):
return {'status' : 'error', 'msg' : 'real name: %s must be the [A-Za-z0-9_]{4,16} pattern' %(real_name)}
if not re.match(r'^[A-Za-z0-9@#$%^&+=]{4,16}$', password):
return {'status' : 'error', 'msg' : 'password: %s must be the ^[A-Za-z0-9@#$%^&+=]{4,16}$ pattern' %(password)}
if status not in USER_STATUSES:
status = 'actived'
if role not in ROLES:
role = 'user'
if len(email) > 7 and re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email):
if Backend('user').find_by_email(email):
return {'status' : 'error', 'msg' : 'email:%s is used' %(email)}
if Backend('user').find_by_username(username):
return {'status' : 'error', 'msg' : 'user name:%s is used' %(username)}
user = User(username, email, real_name, password, status, role)
Backend('user').save(user)
return {'status' : 'info', 'msg' : 'saved'}
def run(self):
self.ready = True
LOGGER.debug('Starting thread %d', get_ident())
while self.ready:
self.suspend()
if self.current_task == _SHUTDOWNTASK:
# shutdown the worker thread
self.ready = False
break
try:
if self.current_task:
self.scheduler.app(self.current_task)
self.current_task.fresh()
Backend('task').save(self.current_task)
except Exception as e:
cls, e, tb = sys.exc_info()
LOGGER.exception('Unhandled Error in thread:%s %s',
get_ident(), e)
if not isinstance(e, DBError):
self.current_task.retry(str(e))
Backend('task').save(self.current_task)
finally:
self.current_task = None
self.pool.push(self)
self.event.clear()
def execute(self, task, retry=False):
try:
done = False
thread = self.threadpool.pop()
if thread:
LOGGER.debug('Execute in thread: %s', thread)
thread.current_task = task
thread.resume()
done = True
elif not retry:
LOGGER.info(
'Thread Pool is Full, put the the task:%s to idel_queue',
task.name)
self.put(task)
time.sleep(1)
else:
task.retry('Current scheduler is busy')
LOGGER.info("save task:%s to db, retry...", task.name)
Backend('task').save(task)
except (KeyboardInterrupt, SystemExit):
self.ready = False
if not done and thread:
thread.current_task = _SHUTDOWNTASK
thread.resume()
except Exception as e:
LOGGER.error('Execute error : %s', e)
task.retry(str(e))
Backend('task').save(task)
def login(self, username='', password=''):
username = username.strip()
password = password.strip()
user = Backend('user').find_by_username(username)
if user and user.check(password):
set_secure_cookie('auth', str(user.uid))
raise cherrypy.HTTPRedirect('/task')
return render_template('login.html')
def test_save_after_retry(self):
task = Backend('task').find('job_test')
task.retry('msg')
Backend('task').save(task)
task = Backend('task').find('job_test')
assert task.name == self.task.name
assert task.event == self.task.event
assert task.run_times == 1
assert task.attempts == self.task.attempts + 1
assert task.status == Task.RETRY
def delete_task(self, name):
task = Backend('task').find(name)
if not task:
return {'status': 'error', 'msg': 'Doesn\'t exist the task'}
if not task.is_running():
Backend('task').delete(task)
return {'status': 'redirect', 'msg': 'deleted, wait to redirect to /task', 'url': '/task'}
else:
return {'status': 'error', 'msg': 'The task is runnig'}
def test_find(self):
user = Backend('user').find(self.uid)
assert user.username == self.user.username
assert user.status == self.user.status
assert user.uid == self.uid
user = Backend('user').find_by_email(self.user.email)
assert user.username == self.user.username
assert user.status == self.user.status
assert user.uid == self.uid
def edit_task_page(self, name):
task = Backend('task').find(name)
if not task:
raise cherrypy.HTTPError(404, 'nof found')
if not task.data:
task.data = ''
else:
task.data = json_encode(task.data)
return render_template('task.edit.html', task=task, statuses=TASK_STATUSES)
def add_task(self, name, action, data, event, status='new'):
name, action, data, event = name.strip(), action.strip(), data.strip(), event.strip()
if name and Backend('task').find(name):
return {'status': 'error', 'msg': 'Exist the task'}
try:
action, data, status = self.process_task_args(action, data, status)
task = Task(None, None, name, action, data, event)
if Backend('task').save(task):
return {'status': 'success', 'msg': 'created'}
except TypeError as e:
return {'status': 'error', 'msg': str(e)}
def test_save(self):
# on dup
user = Backend('user').find(self.uid)
user.status = 'banned'
Backend('user').save(user)
user = Backend('user').find(self.uid)
assert user.status == 'banned'
# new case
user = User('username', 'email2', 'real_name', 'password', 'active')
Backend('user').save(user)
user = Backend('user').find_by_email(self.user.email)
assert user is not None
def test_save(self):
task = Backend('task').find('job_test')
task.fresh()
task.attempts += 1
task.status = Task.COMPLETED
Backend('task').save(task)
task = Backend('task').find('job_test')
assert task.name == self.task.name
assert task.event == self.task.event
assert task.run_times == 1
assert task.attempts == self.task.attempts + 1
assert task.status == Task.COMPLETED
assert task.last_five_logs[0]['status'] == Task.SCHEDULED
def test_save(self):
# on dup
user = Backend('user').find(self.uid)
user.status = 'banned'
Backend('user').save(user)
user = Backend('user').find(self.uid)
assert user.status == 'banned'
# new case
user = User('username', 'email2', 'real_name', 'password', 'active')
Backend('user').save(user)
user = Backend('user').find_by_email(self.user.email)
assert user is not None
def setUp(self):
setattr(db, '__connections', {})
db.setup('localhost',
'test',
'test',
'eden',
pool_opt={
'minconn': 3,
'maxconn': 10
})
self.task = Task(None, 'task_id', 'job_test', 'job.test', {
'args': (),
'kw': {}
}, 'every 5')
Backend('task').delete_by_name('job_test')
Backend('task').save(self.task)
def user_index(self, page=1):
user = cherrypy.request.user
if user.role != 'root':
raise cherrypy.HTTPRedirect('/user/%d/edit' % (user.uid))
page = int(page)
users = Backend('user').paginate(page, 10)
return render_template('user.index.html', users=users)
def task_page(self, status='all', name='', page=1):
# process page , keep it within range(1, 2000)
try:
page = int(page)
except TypeError:
page = 1
if page > 2000:
page = 2000
_status = TASK_STATUSES.get(status, 0)
name = name.strip()
tasks = Backend('task').take(name, _status, page)
count = Backend('task').count(name, _status)
glue = '?page=' if not name else '?name=%s&page=' % (name)
tasks = Paginator(tasks, count, page, 20, '/task/status/%s' % (status), glue)
return render_template('task.index.html', name=name, status=status,
statuses=TASK_STATUS_LIST, key_statuses=TASK_KEY_STATUSES, tasks=tasks)
def test_find(self):
task = Backend('task').find('job_test')
assert task.name == self.task.name
assert task.status == self.task.status
assert task.event == self.task.event
assert task.attempts == self.task.attempts
task = Backend('task').find_by_task_id('task_id')[0]
assert task.name == self.task.name
assert task.status == self.task.status
assert task.event == self.task.event
assert task.attempts == self.task.attempts
task = Backend('task').find_by_cron_id(task.cron_id)
assert task.name == self.task.name
assert task.status == self.task.status
assert task.event == self.task.event
assert task.attempts == self.task.attempts
def stop(self):
self.heartbeat.stop()
idel_queue_size = self._idel_tasks.qsize()
for _ in range(idel_queue_size):
task = self.get()
task.retry('Current schedule was stoped')
Backend('task').save(task)
self.threadpool.stop(self.SHOTDOWN_TIMEOUT)
def test_save(self):
task = Backend('task').find('job_test')
task.fresh()
task.attempts += 1
task.status = Task.COMPLETED
Backend('task').save(task)
task = Backend('task').find('job_test')
assert task.name == self.task.name
assert task.event == self.task.event
assert task.run_times == 1
assert task.attempts == self.task.attempts + 1
assert task.status == Task.COMPLETED
assert task.last_five_logs[0]['status'] == Task.SCHEDULED
def init_user():
"""Load user if the auth session validates."""
uid = get_secure_cookie('auth')
try:
uid = int(uid)
user = Backend('user').find(uid)
if not user:
user = _guest
except TypeError:
user = _guest
request.user = user
def test_save_after_retry(self):
task = Backend('task').find('job_test')
task.retry('msg')
Backend('task').save(task)
task = Backend('task').find('job_test')
assert task.name == self.task.name
assert task.event == self.task.event
assert task.run_times == 1
assert task.attempts == self.task.attempts + 1
assert task.status == Task.RETRY
def _periodic_action(self):
try:
if (time.time() - self.clear_time) > 300:
when = datetime.now() - timedelta(minutes=5)
Backend('task').clear_timeout_task(when)
self.clear_time = time.time()
except:
# Todo: handle db error
pass
# clear idle tasks
idel_queue_size = self._idel_tasks.qsize()
for _ in range(idel_queue_size):
task = self.get()
self.execute(task, True)
def setUp(self):
setattr(db, '__connections', {})
db.setup('localhost',
'test',
'test',
'eden',
pool_opt={
'minconn': 3,
'maxconn': 10
})
self.user = User('username', 'email', 'real_name', 'password',
'active')
db.execute('DELETE FROM users WHERE email=%s or email=%s',
(self.user.email, 'email2'))
Backend('user').save(self.user)
self.uid = db.query_one('SELECT uid FROM users WHERE email=%s',
(self.user.email, ))[0]
def edit_user(self, uid, email, real_name, password, newpass1, newpass2, status, role='user'):
real_name, newpass1, newpass2 = real_name.strip(), newpass1.strip(), newpass2.strip()
uid = int(uid)
user = Backend('user').find(uid)
if not user:
raise cherrypy.HTTPError(404, 'user not found')
me = cherrypy.request.user
if me.uid == user.uid:
if re.match(r'[A-Za-z0-9@#$%^&+=]{4,16}', newpass1):
if password and newpass1 and newpass1 == newpass2:
user.password = newpass1
elif newpass1:
return {'status' : 'error', 'msg' : 'password: %s must be the [A-Za-z0-9_]{4,16} pattern' %(newpass1)}
if len(email) > 7 and re.match("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$", email):
user_ = Backend('user').find_by_email(email)
if user_ and user_.uid != user.uid:
return {'status' : 'error', 'msg' : 'email:%s is used' %(email)}
else:
user.email = email
if me.uid == 1 and user.uid != 1:
if role in (ADMIN, USER):
user.role = role
if user.status != status and status in USER_STATUSES:
user.status = status
if re.match(r'^[A-Za-z0-9_ ]{4,16}$', real_name):
if user.real_name != real_name:
user.real_name = real_name
Backend('user').save(user)
return {'status' : 'info', 'msg' : 'updated'}
def edit_task(self, name, action, data, event, status):
try:
action, data, status = self.process_task_args(action, data, status)
except TypeError as e:
return {'msg': str(e), 'status': 'error'}
task = Backend('task').find(name)
if not task:
raise cherrypy.HTTPError(404, 'nof found')
if not task.is_running():
task.action = action
task.status = status
try:
task.event = event
except:
return {'msg': 'event invalid', 'status': 'error'}
Backend('task').save(task)
return {'status': 'info', 'msg': 'saved', }
else:
return {'status': 'error', 'msg': 'The task is runnig'}
def test_delete(self):
self.user.uid = self.uid
ret = Backend('user').delete(self.user)
user = Backend('user').find(self.uid)
self.assertEqual(user, None)
def test_delete_by_name(self):
task = Backend('task').find('job_test')
ret = Backend('task').delete_by_name(task.name)
task = Backend('task').find('job_test')
self.assertEqual(task, None)
def delete_task(cls, name):
task = Backend('task').find(name)
if not task.is_running():
Backend('task').delete(task)
return True
return False
def test_delete_by_task_id(self):
task = Backend('task').find('job_test')
ret = Backend('task').delete_by_task_id(task.task_id)
task = Backend('task').find('job_test')
self.assertEqual(task, None)
def add_task(cls, name, event, action, next_run=None, *args, **kw):
data = {'args': args, 'kw': kw}
task = Task(None, None, name, action, data, event, next_run=next_run)
return Backend('task').save(task)
def claim(self):
return Backend('task').claim(self.task_size)
def edit_user_page(self, uid):
uid = int(uid)
user = Backend('user').find(uid)
if not user:
raise cherrypy.HTTPError(404, 'user not found')
return render_template('user.edit.html', statuses=USER_STATUSES, roles=ROLES, user=user)
