def host_tree():
user_id = login_user.get('user_id')
is_admin = login_user.get('is_admin')
if is_admin:
groups = db.collection('groups').find({})
group_ids = map(lambda i: i['_id'], groups)
group_ids = list(group_ids)
condition = [{
'$group': {
'_id': '$type',
'count': {
'$sum': 1
}
},
'$match': {
'user_id': user_id,
}
}]
result = db.collection('user_hosts').aggregate(condition)
return jsonify({
'message': 'ok',
'code': 0,
'data': [],
})
def get_current_roles():
username = login_user.get('username')
is_admin = login_user.get('is_admin')
role = Role()
if is_admin:
roles = role.collection.find({})
return jsonify({
'message': 'ok',
'code': 0,
'data': list(roles),
})
user = User()
user_info = user.collection.find_one({'username': username})
where = {
'user_id': str(user_info['_id']),
}
roles = db.collection('user_roles').find(where)
roles = list(roles)
data = []
if roles:
role_ids = map(lambda i: i['role_id'], roles)
data = role.find_by_ids(list(role_ids))
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
})
def get_jobs():
username = login_user.get('username')
query = request.args
page = int(query.get('page', 1))
size = int(query.get('pageSize', 50))
offset = (page - 1) * size
is_admin = login_user.get('is_admin')
keyword = query.get('keyword')
status = query.get('status')
job_type = query.get('type')
start = query.get('start')
end = query.get('end')
where = {'status': {'$gt': -1}}
if not is_admin:
where['maintainer'] = {'$in': [username]}
if keyword:
where['name'] = {'$regex': keyword}
if status is not None:
where['status'] = status
if job_type:
where['type'] = job_type
date = []
if start:
date.append({
'created_at': {
'$gte': int(time.mktime(time.strptime(start, '%Y-%m-%d')))
}
})
if end:
date.append({
'created_at': {
'$lte': int(time.mktime(time.strptime(end, '%Y-%m-%d')))
}
})
if date:
where['$and'] = date
jobs = db.collection('jobs').find(where, skip=offset, limit=size)
total = jobs.count()
jobs = list(jobs)
return jsonify({
'message': 'ok',
'code': 0,
'data': {
'list': jobs,
'total': total,
'page': page,
'pageSize': size,
},
})
def delete_job(_id):
is_admin = login_user.get('is_admin')
record = Job.find_by_id(ObjectId(_id))
if not record:
return jsonify({'message': 'record not found', 'code': 104040}), 404
if not is_admin or login_user.get('username') not in record['maintainer']:
return jsonify({'message': 'permission deny', 'code': 104031}), 403
Job.delete_one({'_id': record['_id']})
return jsonify({
'message': 'ok',
'code': 0,
})
def delete_inventory(_id):
host = Host()
record = host.find_by_id(_id)
if not record:
return jsonify({'message': 'record not found', 'code': 104040}), 404
update = {
'$set': {
'status': -1,
'delete_at': time.time(),
'delete_by': login_user.get('username')
}
}
host.collection.update_one({'_id': record['_id']}, update=update)
msg = 'delete inventory:, hostname: {}'.format(record.get('hostname'))
extra = {
'record': record,
}
logger.info(msg, extra=extra)
return jsonify({
'message': 'ok',
'code': 0,
})
def save_alert():
payload = request.get_json()
if not payload:
return jsonify({
'message': 'invalid params',
'code': 104000
}), 400
alerts = payload.get('alerts')
alert_type = payload.get('type')
if not alerts or type(alerts) != list:
return jsonify({
'message': 'invalid param alerts',
'code': 104001
}), 400
where = {
'_id': ObjectId(login_user.get('user_id'))
}
field = 'alerts.' + alert_type
update = {
'$set': {
field: alerts
}
}
user = User()
record = user.collection.find_one(where)
user.collection.update_one(where, update=update)
logger.info('add alerts', extra={'change': update, 'record': record})
return jsonify({
'message': 'ok',
'code': 0
})
def add_user_to_team():
payload = request.get_json()
if not payload:
return jsonify({'message': 'invalid params', 'code': 104000}), 400
user_id = payload.get('user_id')
team_id = payload.get('team_id')
is_owner = payload.get('is_owner')
team = Team().find_by_id(user_id)
if not team:
return jsonify({'message': 'invalid team', 'code': 104031}), 400
where = {
'team_id': team_id,
'user_id': user_id,
'is_owner': is_owner,
}
data = where.copy()
data['created_at'] = time.time()
data['add_by'] = login_user.get('username')
db.collection('team_members').update_one(where, {'$set': data},
upsert=True)
role = db.collection('roles').find_one({
'name': team.get('name'),
'type': 'team',
})
return jsonify({
'message': 'ok',
'code': 0,
})
def delete_user(_id):
is_admin = login_user.get('is_admin')
if not is_admin:
return jsonify({
'message': 'admin required',
'code': 104033,
}), 403
record = User.find_by_id(_id)
if not record:
return jsonify({
'message': 'record not found',
'code': 104040,
}), 404
update = {
'$set': {
'status': -1,
'delete_at': time.time(),
}
}
condition = {'_id': record['_id']}
User.update_one(condition, update=update)
TeamMember.delete_one({'user_id': _id})
user_roles = UserRole.find(condition)
for item in user_roles:
where = {'_id': item['_id']}
UserRole.delete_one(where)
return jsonify({
'message': 'ok',
'code': 0,
})
def bind_role(user_id):
payload = request.get_json()
if not payload:
return jsonify({'message': 'invalid params', 'code': 104030}), 400
role_ids = payload.get('role_ids')
if not role_ids or type(role_ids) != list:
return jsonify({'message': 'invalid params', 'code': 104031}), 400
user = User()
user_info = user.find_by_id(user_id)
if not user_info:
return jsonify({'message': 'record not found', 'code': 104040}), 404
roles = Role().find_by_ids(role_ids)
if not roles:
return jsonify({'message': 'invalid param', 'code': 104031}), 400
for role in roles:
data = {
'user_id': user_id,
'role_id': str(role['_id']),
}
where = data.copy()
data['created_at'] = time.time()
data['add_by'] = login_user.get('username')
db.collection('user_roles').update_one(where, {'$set': data},
upsert=True)
return jsonify({
'message': 'ok',
'code': 0,
})
def get_notify():
query = request.args
page = abs(int(query.get('page', 1)))
size = abs(int(query.get('pageSize', 20)))
sort = query.get('sort', '_id')
unread = query.get('unread')
skip = (page - 1) * size
model = Notification()
where = {'user_id': login_user.get('user_id')}
if unread:
where['read'] = 0
cursor = model.collection.find(where, skip=skip, limit=size).sort(sort, -1)
total = cursor.count()
return jsonify({
'message': 'ok',
'code': 0,
'data': {
'list': list(cursor),
'total': total,
'page': page,
'pageSize': size,
}
})
def send_verify_mail():
user_id = login_user.get('user_id')
record = User().find_by_id(user_id)
if not record:
return jsonify({
'message': 'invalid user',
'code': 104033
}), 403
email = record.get('email')
token = md5(str(current_request_id))
url = config.dommain + '/users/email/verify?token=' + token
message = '[Eclogue]Please click url to verify your email:<a href="{}">{}</a>'.format(url, url)
smtp = SMTP()
smtp.send(message, email, subtype='html')
data = {
'user_id': user_id,
'token': token,
'created_at': time.time(),
'email': email,
'content': message,
}
db.collection('mail_verify').insert_one(data)
return jsonify({
'message': 'ok',
'code': 0
})
def mark_read():
payload = request.get_json()
if not payload:
return jsonify({'message': 'invalid params', 'code': 104000}), 400
ids = payload.get('ids')
if type(ids) != list:
return jsonify({'message': 'invalid param', 'code': 104001}), 400
user_id = login_user.get('user_id')
ids = map(lambda i: ObjectId(i), ids)
ids = list(ids)
where = {
'user_id': user_id,
'_id': {
'$in': ids,
}
}
update = {'$set': {'read': 1}}
Notification().collection.update_many(where, update=update)
return jsonify({
'message': 'ok',
'code': 0,
})
def run_job(_id, history_id=None, **kwargs):
db = Mongo()
record = Job.find_by_id(_id)
if not record:
return False
request_id = str(current_request_id())
username = None if not login_user else login_user.get('username')
params = (_id, request_id, username, history_id)
queue_name = get_queue_by_job(_id)
extra = record.get('extra')
template = record.get('template')
schedule = extra.get('schedule')
ansible_type = record.get('type')
if template.get('run_type') == 'schedule':
existed = db.collection('scheduler_jobs').find_one(
{'_id': record['_id']})
if existed:
return False
scheduler.add_job(func=run_schedule_task,
trigger='cron',
args=params,
coalesce=True,
kwargs=kwargs,
id=str(record.get('_id')),
max_instances=1,
name=record.get('name'),
**schedule)
return True
else:
func = run_playbook_task if ansible_type != 'adhoc' else run_adhoc_task
task = Task(tiger,
func=func,
args=params,
kwargs=kwargs,
queue=queue_name,
unique=True,
lock=True,
lock_key=_id)
task_record = {
'job_id': _id,
'type': 'trigger',
'ansible': ansible_type,
'state': QUEUED,
'queue': queue_name,
'result': '',
'request_id': request_id,
't_id': task.id,
'created_at': time(),
'kwargs': kwargs,
}
result = db.collection('tasks').insert_one(task_record)
task.delay()
return result.inserted_id
def groups():
query = request.args or {}
keyword = query.get('keyword')
start = query.get('start')
end = query.get('end')
page = int(query.get('page', 1))
limit = int(query.get('pageSize', 50))
region = query.get('region')
where = {'status': {'$ne': -1}}
if region:
where['region'] = query.get('region')
if keyword:
where['name'] = {'$regex': keyword}
date = []
if start:
date.append({
'created_at': {
'$gte': int(time.mktime(time.strptime(start, '%Y-%m-%d')))
}
})
if end:
date.append({
'created_at': {
'$lte': int(time.mktime(time.strptime(end, '%Y-%m-%d')))
}
})
if date:
where['$and'] = date
offset = (page - 1) * limit
is_all = query.get('all')
if is_all and login_user.get('is_admin'):
records = db.collection('groups').find({})
else:
records = db.collection('groups').find(where, limit=limit, skip=offset)
total = records.count()
records = list(records)
for group in records:
region = db.collection('regions').find_one(
{'_id': ObjectId(group['region'])})
group['region_name'] = region.get('name')
return jsonify({
'message': 'ok',
'code': 0,
'data': {
'list': list(records),
'page': page,
'pagesize': limit,
'total': total
}
})
def add_folder():
params = request.get_json()
if not params or not params.get('id') or not params.get('folder'):
return jsonify({
'message': 'illegal param',
'code': 104000,
}), 400
record_id = params.get('id')
folder = params.get('folder')
parent = params.get('parent')
book_id = params.get('book_id')
parent = parent if parent != '.' else '/'
parent_path = None
if parent != '/':
parent_record = Playbook.find_one({
'_id': ObjectId(record_id),
'is_dir': True
})
if not parent_record:
return jsonify({
'message': 'invalid params',
'code': 104001,
}), 400
parent_path = parent_record.get('path')
file_path = os.path.join(parent, folder)
record = {
'path': file_path,
'book_id': book_id,
'parent': parent_path,
'is_dir': True,
'content': '',
'is_edit': False,
'add_by': login_user.get('username'),
'created_at': int(time.time()),
'updated_at': datetime.datetime.now().isoformat(),
}
meta = get_meta(file_path)
record.update(meta)
record['additions'] = meta
check = Playbook.find_one({'book_id': book_id, 'path': record['path']})
if check:
additions = check.get('additions') or {}
additions.update(meta)
record['additions'] = additions
Playbook.update_one({'_id': check['_id']}, {'$set': record})
else:
Playbook.insert_one(record)
return jsonify({
'message': 'ok',
'code': 0,
})
def get_group_hosts(_id):
user_id = login_user.get('user_id')
is_admin = login_user.get('is_admin')
# @todo super admin
where = {
'user_id': user_id,
'group_id': _id,
}
records = db.collection('user_hosts').find(where)
hids = map(lambda i: ObjectId(i.get('host_id')), records)
hosts = db.collection('machines').find({'_id': {'$in': list(hids)}})
return jsonify({
'message': 'ok',
'code': 0,
'data': {
'group': _id,
'hosts': list(hosts),
}
})
def get_team_tree():
is_admin = login_user.get('is_admin')
username = login_user.get('username')
where = {}
if not is_admin:
where = {'master': {'$in': [username]}}
teams = db.collection('teams').find(where)
teams = list(teams)
tree = []
for team in teams:
item = {
'title': team['name'],
'key': team['_id'],
'team': team.get('name'),
}
relations = db.collection('team_members').find(
{'team_id': str(team['_id'])})
relations = list(relations)
if not relations:
tree.append(item)
continue
user_ids = map(lambda i: i['user_id'], relations)
user_ids = list(user_ids)
users = User.find_by_ids(user_ids)
children = []
for user in users:
children.append({
'title': user.get('nickname'),
'key': user.get('_id'),
'team': None,
})
item['children'] = children
tree.append(item)
return jsonify({
'message': 'ok',
'code': 0,
'data': tree,
})
def delete_group(_id):
record = db.collection('groups').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'record not found',
'code': 104040,
}), 404
if not login_user.get('is_admin'):
return jsonify({
'message': 'permission deny',
'code': 104030,
}), 403
if not record.get('add_by'):
return jsonify({'message': 'protected record', 'code': 10086}), 400
update = {
'$set': {
'status': -1,
'delete_at': time.time(),
'delete_by': login_user.get('username')
}
}
group_id = str(record['_id'])
db.collection('groups').update_one({'_id': record['_id']}, update=update)
where = {'group': {'$in': [group_id]}}
Host().collection.update_many(where, {'$pull': {'group': group_id}})
msg = 'delete inventory:, name: {}'.format(record.get('name'))
extra = {
'record': record,
}
logger.info(msg, extra=extra)
return jsonify({
'message': 'ok',
'code': 0,
})
def format(self, record):
"""Formats LogRecord into python dictionary."""
# Standard document
message = record.getMessage()
hostname = socket.gethostname()
if record.name == 'ansible':
message = record.getMessage()
for lp in sys.path:
message = message.replace(
lp, os.path.relpath(lp, config.home_path))
document = {
'hostname': hostname,
'ip': socket.gethostbyname(hostname),
'timestamp': datetime.datetime.utcnow(),
'level': record.levelname,
'thread': record.thread,
'threadName': record.threadName,
'message': message,
'loggerName': record.name,
'fileName': os.path.relpath(record.pathname, config.home_path),
'module': record.module,
'method': record.funcName,
'lineNumber': record.lineno,
'processName': record.processName,
}
# Standard document decorated with exception info
if record.exc_info is not None:
document.update({
'exception': {
'message': str(record.exc_info[1]),
'code': 0,
'stackTrace': self.formatException(record.exc_info)
}
})
# Standard document decorated with extra contextual information
if len(self.DEFAULT_PROPERTIES) != len(record.__dict__):
contextual_extra = set(record.__dict__).difference(
set(self.DEFAULT_PROPERTIES))
if contextual_extra:
for key in contextual_extra:
document[key] = record.__dict__[key]
user = None
if not document.get('currentUser') and login_user:
user = login_user.get('username')
document['currentUser'] = user
return document
def get_menus():
query = request.args
user_id = login_user.get('user_id')
is_admin = login_user.get('is_admin')
name = query.get('name')
route = query.get('route')
status = query.get('status')
where = {'status': {'$ne': -1}}
if name:
where['name'] = name
if route:
where['route'] = route
if status is not None and int(status) >= 0:
where['status'] = int(status)
# is_admin = False
if not is_admin:
user = User()
permissions = user.get_permissions(user_id, filter=where)
menus = permissions[0]
else:
def add_actions(item):
item['actions'] = ['get', 'post', 'delete', 'put', 'patch']
return item
if query and int(query.get('all')):
where = {'status': {'$ne': -1}}
menus = db.collection('menus').find(where).sort('id', 1)
menus = map(add_actions, menus)
return jsonify({'message': 'ok', 'code': 0, 'data': list(menus)})
def get_host_groups(user_id):
current_user_id = login_user.get('user_id')
# query = request.args
# page = int(query.get('page', 1))
# limit = int(query.get('pageSize', 20))
# skip = (page - 1) * limit
if current_user_id != user_id:
return jsonify({'message': 'invalid user', 'code': 104030})
tree = get_inventory_from_cmdb()
return jsonify({
'message': 'ok',
'code': 0,
'data': tree,
})
def bind_user():
payload = request.get_json()
if not payload:
return jsonify({
'message': 'invalid params',
'code': 104000,
}), 400
user_id = payload.get('user_id')
roles = payload.get('roles')
if not user_id or not roles:
return jsonify({
'message': 'invalid params',
'code': 104000,
}), 400
user = User().find_by_id(user_id)
if not user:
return jsonify({
'message': 'invalid user',
'code': 104001,
}), 400
where = {'_id': {'$in': roles}}
role_records = db.collection('roles').find(where)
roles = map(lambda i: str(i['_id']), role_records)
roles = list(roles)
if not roles:
return jsonify({
'message': 'invalid roles',
'code': 104003,
}), 400
data = {
'user_id': user['_id'],
'roles': roles,
'add_by': login_user.get('username'),
'created_at': time.time()
}
db.collection('user_roles').insert_one(data)
return jsonify({
'message': 'ok',
'code': 0,
})
def delete_menu(_id):
is_admin = login_user.get('is_admin')
if not is_admin:
return jsonify({'message': 'permission deny', 'code': 104010}), 401
record = db.collection('menus').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'record not found',
'code': 104040
}), 404
db.collection('menus').delete_one({'_id': record['_id']})
return jsonify({
'message': 'ok',
'code': 0,
})
def get_user_menus():
username = login_user.get('username')
user = db.collection('users').find_one({'username': username})
records = db.collection('user_roles').find_one(
{'user_id': user.get('_id')})
menus = set()
for record in records:
menus.update(record.get('menus'))
menus = list(map(lambda i: ObjectId(i), menus))
where = {'_id': {'$in': menus}}
bucket = db.collection('menus').find(where)
return jsonify({
'message': 'ok',
'code': 0,
'data': bucket,
})
def reset_pwd():
payload = request.get_json()
if not payload:
return jsonify({
'message': 'illegal params',
'code': 104000,
}), 400
old_password = payload.get('old_pwd')
new_password = payload.get('new_pwd')
confirm = payload.get('confirm')
if not old_password or not new_password or not confirm:
return jsonify({
'message': 'miss required params',
'code': 104001
}), 400
if new_password != confirm:
return jsonify({
'message': 'inconsistent confirm password',
'code': 104002
}), 400
user = User().find_by_id(login_user.get('user_id'))
checked = check_password_hash(user.get('password'), old_password)
if not checked:
return jsonify({
'message': 'password incorrect',
'code': 104003,
}), 400
pwd = generate_password_hash(new_password)
update = {
'$set': {
'password': pwd,
}
}
User().collection.update_one({'_id': user['_id']}, update=update)
return jsonify({
'message': 'ok',
'code': 0,
})
def add_configuration():
payload = request.get_json()
if not payload:
return jsonify({
'message': 'invalid params',
'code': 184000,
}), 400
name = payload.get('name')
if not name:
return jsonify({
'message': 'invalid name',
'code': 184001,
}), 400
existed = Configuration.find_one({'name': name})
if existed:
return jsonify({
'message': 'name existed',
'code': 184002,
}), 400
description = payload.get('description')
maintainer = payload.get('maintainer') or []
variables = payload.get('variables')
status = payload.get('status', 0) or 0
data = {
'name': name,
'description': description,
'maintainer': maintainer,
'variables': variables,
'status': status,
'add_by': login_user.get('username'),
'created_at': int(time.time())
}
result = Configuration.insert_one(data)
data['_id'] = result.inserted_id
return jsonify({
'message': 'ok',
'code': 0,
})
def delete_inventory(_id):
host = Host()
record = host.find_by_id(_id)
if not record:
return jsonify({'message': 'record not found', 'code': 104040}), 404
update = {
'$set': {
'status': -1,
'delete_at': time.time(),
'delete_by': login_user.get('username')
}
}
host.update_one({'_id': record['_id']}, update=update)
return jsonify({
'message': 'ok',
'code': 0,
})
def add_member(self, team_id, members, owner_id):
if not members:
return False
team = self.find_by_id(team_id)
if not login_user.get('is_admin'):
if not team or owner_id not in team.get('master'):
return False
current_user = db.collection('users').find_one({'_id': ObjectId(owner_id)})
for user_id in members:
where = {
'user_id': user_id,
}
data = where.copy()
data['team_id'] = team_id
data['created_at'] = time.time()
data['add_by'] = current_user.get('username')
TeamMember.update_one(where, {'$set': data}, upsert=True)
def delete_book(_id):
record = Book.find_by_id(_id)
if not record:
return jsonify({'message': 'record not found', 'code': 154041}), 404
update = {
'$set': {
'status': -1,
'delete_at': time.time(),
'delete_by': login_user.get('username'),
'version': str(ObjectId()),
}
}
Book.update_one({'_id': record['_id']}, update=update)
db.collection('playbook').update_many({'book_id': str(record['_id'])},
update=update)
return jsonify({
'message': 'ok',
'code': 0,
})
def run(_id):
book = Book.find_by_id(_id)
if not book:
return jsonify({'message': 'record not found', 'code': 10404}), 404
payload = request.get_json()
options = payload.get('options')
entry = options.get('entry')
args = options.get('args')
req_id = str(current_request_id())
params = {
'username': login_user.get('username'),
'req_id': req_id,
'args': args,
'options': options
}
result = dispatch(_id, entry, params)
if not result:
return jsonify({'message': 'invalid request', 'code': 104008}), 400
return jsonify({'message': 'ok', 'code': 0, 'data': {'taskId': result}})
