def get():
form, error = JsonParser(
Argument('page', type=int, default=1, required=False),
Argument('pagesize', type=int, default=10, required=False),
Argument('job_group', type=str, required=False),).parse(request.args)
if error is None:
if form.job_group:
job = Job.query.filter_by(group=form.job_group).order_by(Job.enabled.desc())
else:
job = Job.query.order_by(Job.enabled.desc())
total = job.count()
job_data = job.limit(form.pagesize).offset((form.page - 1) * form.pagesize).all()
jobs = [x.to_json() for x in job_data]
now = datetime.now()
for job in jobs:
if not job['enabled']:
job['next_run_time'] = '未启用'
elif str(job['id']) in scheduler.jobs:
next_run_time = scheduler.jobs[str(job['id'])].next_run_time
if next_run_time is None:
job['next_run_time'] = '已过期'
else:
job['next_run_time'] = human_diff_time(next_run_time.replace(tzinfo=None), now)
elif job['trigger'] == 'date' and now > datetime.strptime(job['trigger_args'], '%Y-%m-%d %H:%M:%S'):
job['next_run_time'] = '已过期'
else:
job['next_run_time'] = '异常'
return json_response({'data': jobs, 'total': total})
return json_response(message=error)
def get():
form, error = JsonParser(
Argument('page', type=int, default=1, required=False),
Argument('pagesize', type=int, default=10, required=False),
Argument('host_query', type=dict, default={}),
).parse(request.args)
if error is None:
host_data = Host.query
if form.page == -1:
return json_response({
'data': [x.to_json() for x in host_data.all()],
'total': -1
})
if form.host_query.get('name_field'):
host_data = host_data.filter(
Host.name.like('%{}%'.format(form.host_query['name_field'])))
if form.host_query.get('zone_field'):
host_data = host_data.filter_by(zone=form.host_query['zone_field'])
result = host_data.limit(form.pagesize).offset(
(form.page - 1) * form.pagesize).all()
return json_response({
'data': [x.to_json() for x in result],
'total': host_data.count()
})
return json_response(message=error)
def get():
form, error = JsonParser(
Argument('page', type=int, default=1, required=False),
Argument('pagesize', type=int, default=10, required=False),
Argument('name', type=str, required=False),
).parse(request.args)
if error is None:
user = User.query.filter_by(is_supper=False)
if form.name:
user = user.filter(User.nickname.like('%{}%'.format(form.name)))
total = user.count()
users = []
now_time = datetime.now()
for item in user.limit(form.pagesize).offset(
(form.page - 1) * form.pagesize).all():
data = item.to_json(excludes=('password_hash', 'access_token',
'token_expired'))
if item.token_expired:
data['last_login'] = human_diff_time(
now_time,
datetime.fromtimestamp(item.token_expired -
8 * 60 * 60)) + '前'
else:
data['last_login'] = '******'
users.append(data)
return json_response({'data': users, 'total': total})
return json_response(message=error)
def get():
form, error = JsonParser(
Argument('page', type=int, default=1, required=False),
Argument('pagesize', type=int, default=10, required=False),
Argument('tpl_query', type=dict, required=False),
).parse(request.args)
if error is None:
tpl_data = HostExecTemplate.query
if form.page == -1:
return json_response({
'data': [x.to_json() for x in tpl_data.all()],
'total': -1
})
if form.tpl_query['name_field']:
tpl_data = tpl_data.filter(
HostExecTemplate.tpl_name.like('%{}%'.format(
form.tpl_query['name_field'])))
if form.tpl_query['type_field']:
tpl_data = tpl_data.filter_by(
tpl_type=form.tpl_query['type_field'])
result = tpl_data.limit(form.pagesize).offset(
(form.page - 1) * form.pagesize).all()
return json_response({
'data': [x.to_json() for x in result],
'total': tpl_data.count()
})
return json_response(message=error)
def setting_post(owner_id):
form, error = JsonParser(
Argument('name',
filter=lambda x: x in [
'__MEM_LIMIT', '__NETWORK_MODE', '__EXPOSE_PORT',
'__BIND_VOLUME', '__DNS_SERVER', '__HOST_NAME'
],
help='无效的设置参数！'), Argument('value', type=dict),
'desc').parse()
if error is None:
ok, message = valid_app_setting(form.name, form.value.values())
if not ok:
return json_response(message=message)
values = form.pop('value')
config_key = ConfigKey.query.filter_by(owner_type='app',
owner_id=owner_id,
name=form.name,
type='system').first()
if not config_key:
config_key = ConfigKey(owner_type='app',
owner_id=owner_id,
type='system',
**form).save()
for env_id, value in values.items():
config_value = ConfigValue.query.filter_by(
env_id=env_id, key_id=config_key.id).first()
if config_value:
config_value.update(value=value)
else:
ConfigValue(key_id=config_key.id, env_id=env_id,
value=value).save()
return json_response()
return json_response(message=error)
def get():
form, error = JsonParser(
Argument('page', type=int, default=1, required=False),
Argument('pagesize', type=int, default=10, required=False),
Argument('notify_query', type=dict, required=False),
).parse(request.args)
if error is None:
notify_data = NotifyWay.query
if form.page == -1:
return json_response({
'data': [x.to_json() for x in notify_data.all()],
'total':
-1
})
if form.notify_query.get('name_field'):
notify_data = notify_data.filter(
NotifyWay.name.like('%{}%'.format(
form.notify_query['name_field'])))
result = notify_data.limit(form.pagesize).offset(
(form.page - 1) * form.pagesize).all()
return json_response({
'data': [x.to_json() for x in result],
'total': notify_data.count()
})
return json_response(message=error)
def post():
form, error = JsonParser(
Argument('app_id', type=int),
Argument('env_id', type=int),
Argument('menu_id', type=int),
Argument('message', default=''),
Argument('host_ids', type=list)
).parse()
if error is None:
pro = App.query.get_or_404(form.app_id)
env = Environment.query.get_or_404(form.env_id)
menu = DeployMenu.query.get_or_404(form.menu_id)
ctr_name = '%s.%s' % (pro.identify, env.identify)
if menu.position == 2:
cli = Host.query.get_or_404(form.host_ids[0])
ctr = Container(cli.docker_uri, ctr_name)
if menu.display_type == 2:
exec_code, _ = ctr.exec_command_with_base64(menu.command, form.message, with_exit_code=True)
return json_response(exec_code)
elif menu.display_type == 1:
token = uuid.uuid4().hex
queue = QueuePool.make_queue(token, 1)
queue.containers = [ctr]
Thread(target=do_exec_with_stream,
args=(token, ctr, menu.command, form.message, 10 * 60)).start()
return json_response(token)
# 发布区自定义菜单只允许通知成功与否，固无需判断display_type
elif menu.position == 1:
token = uuid.uuid4().hex
hosts = Host.query.filter(Host.id.in_(form.host_ids)).all()
queue = QueuePool.make_queue(token, len(hosts))
for cli in hosts:
ctr = Container(cli.docker_uri, ctr_name)
Thread(target=do_exec, args=(queue, ctr, cli.name, menu.command, form.message)).start()
return json_response({'token': token, 'data': [{'name': x.name} for x in hosts]})
def bind_menus(app_id):
all_valid_menus = get_built_in_menus()
form, error = JsonParser(
Argument('name',
filter=lambda x: x in all_valid_menus,
help='无效的菜单名称！',
default=''), Argument('command', default='')).parse()
if error is None:
if form.name is '': # 可能通过发布页提供的添加预定义菜单的请求，格式[{name: 'x', desc: 'x', command: 'x'} ...]
post_data = request.get_json()
if isinstance(post_data, list) and all([
isinstance(x, dict) and x['name'] in all_valid_menus
for x in post_data
]):
for item in post_data:
tmp = all_valid_menus[item['name']]
tmp['command'] = item.get('command')
tmp['app_id'] = app_id
DeployMenu.upsert({
'app_id': app_id,
'name': item['name']
}, **tmp)
return json_response()
else:
return json_response(message='错误的参数！')
form.desc = get_built_in_menus()[form.name]['desc']
form.app_id = app_id
DeployMenu.upsert({'app_id': app_id, 'name': form.name}, **form)
return json_response(message=error)
def get_schedule():
form, error = JsonParser(
Argument('page', type=int, default=1, required=False),
Argument('pagesize', type=int, default=10, required=False),
Argument('job_group', type=str, required=False),
Argument('job_name', type=str, required=False),
Argument('job_id', type=int, required=False),
).parse(request.args)
if error is None:
job = db.session.query(JobSchedule)
if form.job_group:
job = JobSchedule.query.filter_by(group=form.job_group).order_by(
JobSchedule.update_time.desc())
if form.job_name:
job = job.filter(
JobSchedule.job_name.like("%" + form.job_name + "%"))
if form.job_id:
job = job.filter_by(job_id=form.job_id)
job = job.order_by(JobSchedule.update_time.desc())
total = job.count()
job_data = job.limit(form.pagesize).offset(
(form.page - 1) * form.pagesize).all()
jobs = [x.to_json() for x in job_data]
return json_response({'data': jobs, 'total': total})
return json_response(message=error)
def publish_permission(role_id):
form, error = JsonParser(Argument('app_ids', type=list), Argument('env_ids', type=list)).parse()
if error is None:
str_app_ids = [str(x) for x in form.app_ids]
str_env_ids = [str(x) for x in form.env_ids]
role = Role.query.get_or_404(role_id)
role.update(app_ids=','.join(str_app_ids), env_ids=','.join(str_env_ids))
return json_response(message=error)
def setting_info():
form, error = JsonParser(
Argument('nickname', help='请输入昵称'),
Argument('mobile', help='请输入手机号码'),
Argument('email', help='请输入电子邮件地址'),
).parse()
if error is None:
g.user.update(**form)
return json_response(message=error)
def setting_password():
form, error = JsonParser(Argument('password', help='请输入原密码'),
Argument('newpassword', help='请输入新密码')).parse()
if error is None:
if g.user.verify_password(form.password):
g.user.password = form.newpassword
g.user.save()
else:
return json_response(message='原密码错误')
return json_response(message=error)
def post():
form, error = JsonParser(
'name', 'type', 'zone', 'ssh_ip', 'ssh_port',
Argument('docker_uri', nullable=True, required=False),
Argument('desc', nullable=True, required=False)).parse()
if error is None:
host = Host(**form)
host.save()
return json_response(host)
return json_response(message=error)
def put(host_id):
form, error = JsonParser(
'name', 'type', 'zone', 'ssh_ip', 'ssh_port',
Argument('docker_uri', nullable=True, required=False),
Argument('desc', nullable=True, required=False)).parse()
if error is None:
host = Host.query.get_or_404(host_id)
host.update(**form)
return json_response(host)
return json_response(message=error)
def put(job_id):
form, error = JsonParser('bu_name', 'owner', 'name', 'group', 'desc',
'command', 'targets',
Argument('bu_name', default='ad_user'),
Argument('owner', default='rui.lu'),
Argument('command_user',
default='ad_user')).parse()
if error is None:
job = Job.query.get_or_404(job_id)
job.update(**form)
return json_response(message=error)
def post():
form, error = JsonParser('nickname', 'username', 'password',
Argument('role_id', type=int, help='请选择角色'),
Argument('email', nullable=True),
Argument('mobile', nullable=True)).parse()
if error is None:
username_is_exist = User.query.filter_by(username=form.username).first()
if username_is_exist:
return json_response(message="用户名已存在")
User(**form).save()
return json_response()
return json_response(message=error)
def set_trigger(job_id):
form, error = JsonParser(
Argument('trigger', filter=lambda x: x in ['cron', 'date', 'interval'], help='错误的调度策略！'),
Argument('trigger_args')
).parse()
if error is None:
if not scheduler.valid_job_trigger(form.trigger, form.trigger_args):
return json_response(message='数据格式校验失败！')
job = Job.query.get_or_404(job_id)
if job.update(**form):
scheduler.update_job(job)
return json_response(message=error)
def get():
form, error = JsonParser(Argument('page', type=int, default=1, required=False),
Argument('pagesize', type=int, default=10, required=False),
Argument('host_zone', type=str, required=False),).parse(request.args)
if error is None:
if form.page == -1:
hosts_data = Host.query.all()
return json_response({'data': [x.to_json() for x in hosts_data], 'total': -1})
elif form.host_zone:
hosts = Host.query.filter_by(zone=form.host_zone)
else:
hosts = Host.query
hosts_data = hosts.limit(form.pagesize).offset((form.page - 1) * form.pagesize).all()
return json_response({'data': [x.to_json() for x in hosts_data], 'total': hosts.count()})
return json_response(message=error)
def app_update():
form, error = JsonParser(Argument('app_id', type=int),
Argument('env_id', type=int),
Argument('deploy_message', default=''),
Argument('deploy_restart', type=bool),
Argument('host_ids', type=list)).parse()
if error is None:
if not g.user.check_deploy_permission(form.env_id, form.app_id):
return json_response(message='Permission denied'), 403
token = uuid.uuid4().hex
q = QueuePool.make_queue(token, len(form.host_ids))
for host_id in form.pop('host_ids'):
Thread(target=do_update, args=(q, form, host_id)).start()
return json_response(token)
return json_response(message=error)
def put(u_id):
form, error = JsonParser('nickname', 'is_active',
Argument('role_id', type=int, required=False, help='请选择角色'),
Argument('email', nullable=True),
Argument('password', nullable=False, required=False),
Argument('mobile', nullable=True)).parse()
if error is None:
u_info = User.query.get_or_404(u_id)
if form.password:
u_info.password = form.password
if not u_info.update(**form) and form.password:
u_info.save()
return json_response(u_info)
return json_response(message=error)
def bind_relationship(app_id):
form, error = JsonParser(Argument('app_ids', type=list),
Argument('service_ids', type=list)).parse()
if error is None:
old_relationships = AppConfigRel.query.filter_by(s_id=app_id).all()[:]
for key, value in [('app', x) for x in form.app_ids
] + [('ser', x) for x in form.service_ids]:
rel = AppConfigRel(s_id=app_id, d_id=value, d_type=key)
if rel in old_relationships:
old_relationships.remove(rel)
else:
rel.add()
for old_rel in old_relationships:
old_rel.delete(commit=False)
db.session.commit()
return json_response(message=error)
def kill_job():
form, error = JsonParser(
'job_schedule_name',
'kill_user',
'hosts_id',
'id',
Argument('command',
type=str,
default='bash /tensorflow/arena_stop/arena_job_kill.sh',
required=False),
).parse()
print("hosts_id" + str(form.hosts_id) + " command:" + form.command)
# 这里操作是ssh后初始化环境变量
new_command = "source /etc/profile &&. /etc/profile && " + form.command + " " + form.kill_user + " " + form.job_schedule_name + " " + str(
form.id)
if error is None:
ip_list = Host.query.filter(Host.id.in_(tuple(form.hosts_id))).all()
token = uuid.uuid4().hex
q = QueuePool.make_queue(token, len(ip_list))
for h in ip_list:
print(h.ssh_ip)
Thread(target=hosts_exec,
args=(q, h.ssh_ip, 'ad_user', h.ssh_port,
new_command)).start()
return json_response(token)
return json_response(message=error)
def put(cfg_id):
form, error = JsonParser(
Argument('type',
default='',
filter=lambda x: x in ['private', 'public']), 'short_name',
'desc', 'value').parse()
if error is None:
config_key = ConfigKey.query.get_or_404(cfg_id)
owner = type_id_to_model_instance(config_key.owner_type,
config_key.owner_id)
if form.type in ['private']:
form.name = form.pop('short_name').upper()
else:
form.name = (owner.identify + '_' + form.pop('short_name')).upper()
exists_key = first_config_key(config_key.owner_type,
config_key.owner_id, form)
if exists_key and exists_key.id != cfg_id:
return json_response(message='重复的变量名称！')
for env_id, value in form.pop('value').items():
config_value = ConfigValue.query.filter_by(
env_id=env_id, key_id=config_key.id).first()
if config_value:
config_value.update(value=value)
else:
ConfigValue(key_id=config_key.id, env_id=env_id,
value=value).save()
config_key.update(**form)
return json_response()
return json_response(message=error)
def post():
form, error = JsonParser('user_id', 'db_user', 'db_password',
'db_database', 'db_priv',
Argument('desc', nullable=True,
required=False)).parse()
if error is None:
if not User.query.filter_by(id=form.user_id).first():
return json_response(message="管理员账号错误")
if UserInfo.query.filter_by(user_id=form.user_id,
db_user=form.db_user).first():
return json_response(message="账号已存在，不能重复创建")
cli = User.query.get_or_404(form.user_id)
try:
with MysqlClient(ip=cli.db_host,
user=cli.db_user,
password=cli.db_password,
port=cli.db_port,
db=form.db_database) as f:
f.grant_priv(form.db_user, form.db_password, form.db_database,
form.db_priv)
except Exception as e:
return json_response(message='连接失败')
host = UserInfo(user_id=form.user_id,
db_user=form.db_user,
db_password=form.db_password,
desc=form.desc)
host.save()
userpriv = UserPriv(account_id=host.id,
db_database=form.db_database,
db_priv=form.db_priv)
userpriv.save()
return json_response(host)
return json_response(message=error)
def post():
form, error = JsonParser('name', 'group', 'desc', 'command_user',
'command', 'targets',
Argument('command_user', default='root')).parse()
if error is None:
Job(**form).save()
return json_response(message=error)
def put(user_id):
form, error = JsonParser('name', 'type', 'zone', 'db_host', 'db_user', 'db_password','db_port',
Argument('desc', nullable=True, required=False)).parse()
if error is None:
host = User.query.get_or_404(user_id)
host.update(**form)
return json_response(host)
return json_response(message=error)
def post():
form, error = JsonParser('name', 'type', 'zone', 'db_host', 'db_user', 'db_password','db_port',
Argument('desc', nullable=True, required=False)).parse()
if error is None:
host = User(**form)
host.save()
return json_response(host)
return json_response(message=error)
def put(tpl_id):
form, error = JsonParser('tpl_name', 'tpl_type', 'tpl_content',
Argument('tpl_desc', nullable=True, required=False)).parse()
if error is None:
tpl = HostExecTemplate.query.get_or_404(tpl_id)
tpl.update(**form)
return json_response(tpl)
return json_response(message=error)
def do_exec(field_id):
form, error = JsonParser(Argument('host_id', type=int),
Argument('app_id', type=int),
Argument('env_id', type=int)).parse()
if error is None:
field = DeployField.query.get_or_404(field_id)
pro = App.query.get_or_404(form.app_id)
cli = Host.query.get_or_404(form.host_id)
env = Environment.query.get_or_404(form.env_id)
try:
ctr = Container(cli.docker_uri,
'{}.{}'.format(pro.identify, env.identify))
output = ctr.exec_command_with_base64(field.command, timeout=5)
except DockerException:
output = 'N/A'
return json_response(output.strip())
return json_response(message=error)
def post():
form, error = JsonParser('tpl_name', 'tpl_type', 'tpl_content',
Argument('tpl_desc', nullable=True, required=False)).parse()
if error is None:
tpl = HostExecTemplate(**form)
tpl.save()
return json_response(tpl)
return json_response(message=error)
