def update_region(_id):
where = {'_id': ObjectId(_id)}
record = db.collection('regions').find_one(where)
if not record:
return jsonify({'message': 'record not found', 'code': '124040'}), 404
payload = request.get_json()
if not payload:
return jsonify({
'message': 'miss required params',
'code': 124001
}), 400
data = dict()
allow_fields = [
'platform', 'ip_range', 'bandwidth', 'contact', 'name', 'description'
]
for key, value in payload.items():
if key in allow_fields:
data[key] = value
db.collection('regions').update_one(where, {'$set': data})
data['_id'] = _id
logger.info('update region', extra={'record': record, 'changed': data})
return jsonify({
'message': 'ok',
'code': 0,
})
def delete(_id):
record = db.collection('configurations').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'record not found',
'code': 104040,
}), 404
is_register = Playbook.find_one({'register': {'$in': [str(_id)]}})
if is_register:
return jsonify({
'message':
'target record is bind to playbook: %s' % is_register.get('name'),
'code':
104038
}), 403
Configuration.delete_one({'_id': record['_id']})
msg = 'update configuration, name: {}'.format(record.get('name'))
logger.info(msg, extra={'record': record, 'force': False})
return jsonify({
'message': 'ok',
'code': 0,
})
def delete_task(_id, state):
record = db.collection('tasks').find_one({'t_id': _id})
if not record:
return jsonify({
'message': 'task not found',
'code': 194041
}), 404
task_id = record.get('t_id')
queue = record.get('queue')
try:
task = Task.from_id(tiger, queue, state, task_id)
task._move(from_state=state)
db.collection('tasks').update_one({'_id': record['_id']}, {'$set': {
'updated_at': datetime.now(),
'state': 'delete',
}})
extra = {
'queue': queue,
'task_id': task_id,
'from_state': state,
'to_state': None
}
logger.info('cancel task', extra=extra)
except TaskNotFound:
return jsonify({
'message': 'invalid task',
'code': 104044
}), 404
return jsonify({
'message': 'ok',
'code': 0,
})
def update_group(_id):
where = {'_id': ObjectId(_id)}
record = db.collection('groups').find_one(where)
if not record:
return jsonify({'message': 'record not found', 'code': '124040'}), 404
payload = request.get_json()
if not payload:
return jsonify({
'message': 'miss required params',
'code': 124001
}), 400
data = dict()
for key, value in payload.items():
if record.get('key'):
data[key] = value
db.collection('regions').update_one(where, {'$set', data})
logger.info('update group', extra={'record': record, 'changed': data})
return jsonify({
'message': 'ok',
'code': 0,
})
def retry(_id, state):
record = db.collection('tasks').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'task not found',
'code': 194041
}), 404
task_id = record.get('t_id')
queue = record.get('queue')
try:
task = Task.from_id(tiger, queue, state, task_id)
task.retry()
db.collection('tasks').update_one({'_id': record['_id']}, {'$set': {
'updated_at': datetime.now(),
'state': state,
}})
extra = {
'queue': queue,
'task_id': task_id,
'from_state': state,
'to_state': QUEUED
}
logger.info('retry task', extra=extra)
except TaskNotFound:
return jsonify({
'message': 'invalid task',
'code': 104044
}), 404
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 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 ansible_inventory_patrol():
uuid = str(uuid4())
logger.info('start check ansible inventory', extra={'uuid': uuid})
where = {'state': 'active', 'status': {'$ne': -1}}
page = 1
limit = 50
while True:
skip = (page - 1) * limit
records = Host.find(where, skip=skip, limit=limit)
records = list(records)
if not records:
break
try:
inventory = _pack_inventory(records)
if not inventory:
continue
tasks = [{
'action': {
'module': 'ping',
}
}]
options = {}
runner = AdHocRunner(inventory, options)
runner.run(pattern='all', tasks=tasks)
except Exception as e:
logger.error('ansible inventory patrol catch exception: {}'.format(
str(e)))
finally:
page += 1
logger.info('finish check ansible inventory', extra={'uuid': uuid})
def test_docker():
# print(current_app.logger.handlers)
logger.info('aaaatest23412288886666')
# client = Docker({
# 'base_url': None,
# 'image': 'alpine:latest',
# })
# # result = client.run(command='pwd', working_dir='/usr/lib', detach=False)
# # print(result)
# client.install('/usr/lib')
return jsonify({'message': 'ok'})
def insert_one(cls, data, *args, **kwargs):
model = cls()
if data.get('status') is None:
data['status'] = 1
result = model.collection.insert_one(data, *args, **kwargs)
record = data.copy()
record['_id'] = result.inserted_id
msg = 'insert new record to {}, _id: {}'.format(
model.name, record['_id'])
logger.info(msg, extra={'record': record})
return result
def add_key():
user = login_user
payload = request.get_json()
if not payload:
return jsonify({
'message': 'illegal params',
'code': 104000,
}), 400
public_key = payload.get('public_key')
name = payload.get('name')
if not public_key:
return jsonify({'message': 'invalid public key', 'code': 104000}), 400
ssh = SSHKey(public_key)
try:
ssh.parse()
except Exception as err:
return jsonify({
'message': 'invalid ssh key: {}'.format(str(err)),
'code': 104001,
}), 400
fingerprint = ssh.hash_md5()
existed = db.collection('public_keys').find_one(
{'fingerprint': fingerprint})
if existed:
return jsonify({
'message': 'ssh public key existed',
'code': 104003
}), 400
options = {'vault_pass': config.vault.get('secret')}
encode = Vault(options).encrypt_string(public_key)
data = {
'fingerprint': fingerprint,
'user_id': user.get('user_id'),
'content': encode,
'name': name,
'created_at': time.time()
}
result = db.collection('public_keys').insert_one(data)
data['_id'] = result.inserted_id
logger.info('add public_keys', extra={'record': data})
return jsonify({
'message': 'ok',
'code': 0,
})
def update_configuration(_id):
payload = request.get_json()
if not payload:
return jsonify({
'message': 'invalid params',
'code': 184000,
}), 400
name = payload.get('name')
record = db.collection('configurations').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'record not found',
'code': 104040,
}), 404
description = payload.get('description')
maintainer = payload.get('maintainer') or []
variables = payload.get('variables')
status = payload.get('status')
data = {}
if name:
data['name'] = name
if description:
data['description'] = description
if variables:
data['variables'] = variables
if maintainer:
data['maintainer'] = maintainer
if status is not None:
data['status'] = int(status)
if len(data.keys()):
update = {
'$set': data,
}
db.collection('configurations').update_one({'_id': record['_id']},
update=update)
msg = 'update configuration, name: {}'.format(record.get('name'))
logger.info(msg, extra={'record': record, 'changed': data})
return jsonify({
'message': 'ok',
'code': 0,
})
def delete_job(_id):
record = Job.find_by_id(ObjectId(_id))
if not record:
return jsonify({'message': 'record not found', 'code': 104040}), 404
update = {'$set': {'status': -1}}
Job.update_one({'_id': record['_id']}, update=update)
extra = {'record': record}
logger.info('delete job', extra=extra)
return jsonify({
'message': 'ok',
'code': 0,
})
def edit_book(_id):
params = request.get_json() or request.form
if not params:
return jsonify({
'message': 'invalid params',
'code': 154000,
}), 400
name = params.get('name')
description = params.get('description')
status = params.get('status', 1)
maintainer = params.get('maintainer', [])
import_type = params.get('importType')
galaxy_repo = params.get('galaxyRepo')
record = Book.find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'record not found',
'code': 154041,
}), 404
data = {
'status': status,
}
if name:
data['name'] = name
if description:
data['description'] = description
if maintainer:
data['maintainer'] = maintainer
if import_type == 'galaxy':
galaxy = AnsibleGalaxy([galaxy_repo], {'force': True})
galaxy.install(record.get('_id'))
Book.update_one({'_id': ObjectId(_id)}, {'$set': data}, upsert=True)
logger.info('book update', extra={'record': record, 'changed': data})
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
})
def update_one(cls, where, update, **kwargs):
model = cls()
record = model.collection.find_one(where)
if not record and not kwargs.get('upsert'):
return False
msg = 'update record from {}'.format(model.name)
if record:
msg = msg + ', _id: %s' % record.get('_id')
extra = {
'record': record,
'change': update,
'filter': where,
}
logger.info(msg, extra)
return model.collection.update_one(where, update, **kwargs)
def _remove_dir(_id):
collection = db.collection('playbook')
record = collection.find_one({'_id': ObjectId(_id)})
if not record:
return False
children = collection.find({'parent': record['_id']})
for item in children:
if item.get('is_dir'):
_remove_dir(item['_id'])
continue
collection.delete_one({'_id': item['_id']})
logger.info('delete playbook file', extra={'record': item})
collection.delete_one({'_id': record['_id']})
logger.info('delete playbook file', extra={'record': record})
return True
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 add_menu():
params = request.get_json()
if not params:
return jsonify({'message': 'param required', 'code': 4000}), 400
checked = True
if 'name' not in params:
checked = False
if 'route' not in params:
checked = False
if 'id' not in params:
checked = False
if 'status' in params:
checked = type(params.get('status')) == int
if checked is False:
return jsonify({'message': 'param incorrect', 'code': 104001}), 400
id = str(ObjectId.from_datetime(datetime.datetime.now()))
data = {
'name': params['name'],
'route': params['route'],
'id': id,
'apis': params.get('apis') or [],
'icon': params.get('icon', ''),
'bpid': params.get('bpid') or '0',
'mpid': params.get('mpid') or '0',
'status': params.get('status', 1),
'add_by': login_user.get('username'),
'created_at': time.time()
}
db.collection('menus').insert_one(data)
logger.info('add menu', extra={'record': data})
return jsonify({
'message': 'ok',
'code': 0,
})
def edit_inventory(_id):
user = login_user
payload = request.get_json()
if not payload:
return jsonify({
'message': 'miss required params',
'code': 124001,
}), 400
record = db.collection('machines').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({'message': 'record not found', 'code': 124041}), 400
payload.pop('_id')
payload['updated_at'] = time.time()
update = {'$set': payload}
db.collection('machines').update_one({'_id': record['_id']}, update=update)
logger.info('update machine', extra={'record': record, 'changed': payload})
return jsonify({
'message': 'ok',
'code': 0,
# 'data': diff
})
def add_group():
user = login_user
payload = request.get_json()
if not payload:
return jsonify({'message': 'invalid params', 'code': 124003}), 400
region = payload.get('region')
name = payload.get('name')
if not payload.get('name') or not payload.get('region'):
return jsonify({'message': 'invalid params', 'code': 124004}), 400
dc = db.collection('regions').find_one({'_id': ObjectId(region)})
if not dc:
return jsonify({
'message': 'data center existed',
'code': 124005,
}), 400
check = db.collection('groups').find_one({'name': name})
if check:
return jsonify({
'message': 'group existed',
'code': 124004,
}), 400
data = {
'name': name,
'region': region,
'add_by': user.get('username'),
'description': payload.get('description', ''),
'created_at': int(time.time())
}
result = db.collection('groups').insert_one(data)
data['_id'] = result.inserted_id
logger.info('add group', extra={'record': data})
return jsonify({
'message': 'ok',
'code': 0,
})
def delete_one(cls, where, force=False, **kwargs):
model = cls()
record = model.collection.find_one(where)
if not record:
return None
msg = 'delete record from {}, _id: {}'.format(model.name,
record['_id'])
extra = {
'record': record,
'filter': where,
}
update = {
'$set': {
'delete_at': time.time(),
'status': -1,
}
}
logger.info(msg, extra)
if not force:
return model.collection.update_one(where, update=update, **kwargs)
return model.collection.delete_one(where)
def run_task():
payload = request.get_json()
if not payload:
return jsonify({
'message': 'invalid params',
'code': 114000,
}), 400
run_type = payload.get('type')
inventory = payload.get('inventory')
private_key = payload.get('private_key')
module = payload.get('module')
args = payload.get('args')
entry = payload.get('entry')
become_mehtod = payload.get('become_method')
become_user = payload.get('become_user')
verbosity = payload.get('verbosity', 0) or 1
extra_options = payload.get('extraOptions')
hosts = parse_cmdb_inventory(inventory)
if not hosts:
return jsonify({
'message': 'invalid inventory',
'code': 114001,
}), 400
options = {}
if extra_options:
options.update(extra_options)
if verbosity:
options['verbosity'] = verbosity
if become_mehtod:
options['become'] = 'yes'
options['become_method'] = become_mehtod
if become_user:
options['become_user'] = become_user
if run_type == 'adhoc':
if not module:
return jsonify({
'message': 'invalid module',
'code': 114002,
}), 400
tasks = [{'action': {'module': module, 'args': args}}]
with NamedTemporaryFile('w+t', delete=True) as fd:
if private_key:
key_text = get_credential_content_by_id(
private_key, 'private_key')
if not key_text:
return jsonify({
'message': 'invalid private_key',
'code': 104033,
}), 401
fd.write(key_text)
fd.seek(0)
options['private_key'] = fd.name
runner = AdHocRunner(hosts, options=options)
logger.info('run ansible-adhoc',
extra={
'hosts': hosts,
'options': options
})
res = runner.run('all', tasks)
result = runner.format_result()
return jsonify({'message': 'ok', 'code': 0, 'data': result})
else:
if not entry:
return jsonify({
'message': 'invalid entry',
'code': 114004,
}), 400
with NamedTemporaryFile('w+t', delete=True) as fd:
if private_key:
key_text = get_credential_content_by_id(
private_key, 'private_key')
if not key_text:
return jsonify({
'message': 'invalid private_key',
'code': 104033,
}), 401
fd.write(key_text)
fd.seek(0)
options['private_key'] = fd.name
with NamedTemporaryFile('w+t', delete=True) as fh:
fh.write(entry)
fh.seek(0)
runner = PlayBookRunner(hosts, options)
logger.info('run ansible-playbook',
extra={
'hosts': hosts,
'options': options
})
runner.run(fh.name)
result = runner.format_result()
return jsonify({'message': 'ok', 'code': 0, 'data': result})
def add_book():
params = request.get_json() or request.form
if not params:
return jsonify({
'message': 'invalid params',
'code': 154000,
}), 400
name = params.get('name')
if not name:
return jsonify({
'message': 'name param required',
'code': 154001,
}), 400
existed = Book.find_one({'name': name})
if existed:
return jsonify({
'message': 'book exist',
'code': 154003,
}), 400
description = params.get('description')
status = params.get('status', 1)
bid = params.get('_id')
import_type = params.get('importType')
galaxy_repo = params.get('galaxyRepo')
maintainer = params.get('maintainer', [])
if bid:
record = Book.find_one({'_id': ObjectId(bid)})
if not record:
return jsonify({
'message': 'record not found',
'code': 154041,
}), 404
else:
if import_type == 'galaxy' and galaxy_repo:
galaxy = AnsibleGalaxy([galaxy_repo])
galaxy.install()
logger.info('import galaxy', extra={'repo': galaxy_repo})
data = {
'name': name,
'description': description,
'maintainer': maintainer,
'import_type': import_type,
'galaxy_repo': galaxy_repo,
'status': int(status),
'created_at': int(time.time())
}
result = Book.update_one({'_id': ObjectId(bid)}, {'$set': data},
upsert=True)
data['_id'] = result.upserted_id
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
})
def update_app(_id):
payload = request.get_json()
if not payload:
return jsonify({
'message': 'empty params',
'code': 174000,
}), 400
record = db.collection('apps').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({'message': 'record not found', 'code': 104040}), 404
name = payload.get('name')
app_type = payload.get('type')
params = payload.get('params')
repo = payload.get('repo')
server = payload.get('server')
document = payload.get('document')
protocol = payload.get('protocol')
port = payload.get('port')
description = payload.get('description')
integration = Integration(app_type, params)
check = integration.check_app_params()
update = {}
if not check:
return jsonify({
'message': 'invalid ' + app_type + 'params',
'code': 174003
}), 400
if name != record.get('name'):
existed = db.collection('apps').find_one({'name': name})
if existed:
return jsonify({'message': 'name existed', 'code': 104001}), 400
update['name'] = name
if app_type:
update['type'] = app_type
if params:
update['params'] = params
if server:
update['server'] = server
if document:
update['document'] = document
if repo:
update['repo'] = repo
if port:
update['port'] = port
if protocol:
update['protocol'] = protocol
if description:
update['description'] = description
if update:
update['updated_at'] = time.time()
data = {'$set': update}
# maintainer = payload.get('maintainer') or []
db.collection('apps').update_one({'_id': record['_id']}, update=data)
logger.info('add apps', extra={'record': record, 'changed': update})
return jsonify({
'message': 'ok',
'code': 0,
})
def add_adhoc():
payload = request.get_json()
if not payload:
return jsonify({
'message': 'invalid params',
'code': 104001,
}), 400
module = payload.get('module')
args = payload.get('args')
inventory = payload.get('inventory')
private_key = payload.get('private_key')
verbosity = payload.get('verbosity')
name = payload.get('name')
schedule = payload.get('schedule')
check = payload.get('check')
job_id = payload.get('job_id')
extra_options = payload.get('extraOptions')
status = int(payload.get('status', 0))
notification = payload.get('notification')
maintainer = payload.get('maintainer') or []
if maintainer and isinstance(maintainer, list):
users = db.collection('users').find({'username': {'$in': maintainer}})
names = list(map(lambda i: i['username'], users))
maintainer.extend(names)
maintainer.append(login_user.get('username'))
if not job_id:
existed = db.collection('jobs').find_one({'name': name})
if existed and existed.get('status') != -1:
return jsonify({'message': 'name exist', 'code': 104007}), 400
if not module or not inventory or not name:
return jsonify({
'message': 'miss required params',
'code': 104002,
}), 400
# check_module = db.collection('ansible_modules').find_one({
# 'name': module
# })
#
# if not check_module:
# return jsonify({
# 'message': 'invalid module',
# 'code': 104003,
# }), 400
inventory_content = parse_cmdb_inventory(inventory)
if not inventory:
return jsonify({
'message': 'invalid inventory',
'code': 104004,
}), 400
key_text = get_credential_content_by_id(private_key, 'private_key')
if not key_text:
return jsonify({
'message': 'invalid private key',
'code': 104004,
}), 400
options = {}
if extra_options:
options.update(extra_options)
if verbosity:
options['verbosity'] = verbosity
if check:
with NamedTemporaryFile('w+t', delete=True) as fd:
fd.write(key_text)
fd.seek(0)
options['private_key'] = fd.name
tasks = [{'action': {'module': module, 'args': args}}]
hosts = inventory_content
runner = AdHocRunner(hosts, options=options)
runner.run('all', tasks)
result = runner.get_result()
return jsonify({'message': 'ok', 'code': 0, 'data': result})
else:
token = str(base64.b64encode(bytes(current_request_id(), 'utf8')),
'utf8')
data = {
'name': name,
'template': {
'inventory': inventory,
'private_key': private_key,
'verbosity': verbosity,
'module': module,
'args': args,
'extraOptions': extra_options,
},
'extra': {
'schedule': schedule,
'notification': notification,
},
'token': token,
'maintainer': maintainer,
'type': 'adhoc',
'created_at': time.time(),
'status': status,
'add_by': login_user.get('username')
}
if job_id:
record = db.collection('jobs').find_one({'_id': ObjectId(job_id)})
if not record:
return jsonify({
'message': 'record not found',
'code': 104040
}), 404
update = {
'$set': data,
}
db.collection('jobs').update_one({'_id': ObjectId(job_id)},
update=update)
logger.info('update job',
extra={
'record': record,
'changed': data
})
else:
result = db.collection('jobs').insert_one(data)
data['_id'] = result.inserted_id
logger.info('add job', extra={'record': data})
return jsonify({
'message': 'ok',
'code': 0,
})
def add_apps():
current_user = login_user.get('username')
payload = request.get_json()
if not payload:
return jsonify({
'message': 'empty params',
'code': 174000,
}), 400
name = payload.get('name')
app_type = payload.get('type')
params = payload.get('params')
integration = Integration(app_type, params)
check = integration.check_app_params()
if not check:
return jsonify({
'message': 'invalid ' + app_type + 'params',
'code': 174003
}), 400
if not name or not app_type or not params:
return jsonify({
'message': 'miss required params',
'code': 174001,
}), 400
existed = db.collection('apps').find_one({'name': name})
if existed:
return jsonify({
'message': 'name existed',
'code': 174002,
}), 400
repo = payload.get('repo')
server = payload.get('server')
document = payload.get('document')
protocol = payload.get('protocol')
port = payload.get('port')
description = payload.get('description')
# @todo
# maintainer = payload.get('maintainer') or []
maintainer = [current_user]
maintainer = set(maintainer)
data = {
'name': name,
'server': server,
'document': document,
'type': app_type,
'params': params,
'repo': repo,
'status': 1,
'protocol': protocol,
'port': port,
'description': description,
'maintainer': list(maintainer),
'add_by': login_user.get('username'),
'created_at': int(time.time())
}
logger.info('add apps', extra={'record': data})
Application.insert_one(data)
return jsonify({
'message': 'ok',
'code': 0,
})
def add_team():
payload = request.get_json()
if not payload:
return jsonify({'message': 'invalid params', 'code': 104000}), 400
is_admin = login_user.get('is_admin')
if not is_admin:
return jsonify({'message': 'admin required', 'code': 104039}), 403
name = payload.get('name')
description = payload.get('description')
parent = payload.get('parent')
role_ids = payload.get('role_ids')
members = payload.get('members') or []
master = payload.get('master') or [login_user.get('username')]
record = Team.find_one({'name': name})
if record:
return jsonify({'message': 'name existed', 'code': 104001}), 400
if role_ids:
role_record = Role.find_by_ids(role_ids)
if not role_record:
return jsonify({'message': 'role not found', 'code': 104041}), 404
data = {
'name': name,
'description': description,
'master': master,
'parent': parent,
'add_by': login_user.get('username'),
'created_at': time.time(),
}
result = Team.insert_one(data)
team_id = str(result.inserted_id)
data['_id'] = team_id
logger.info('add team', extra={'record': data})
if not role_ids:
role = {
'name': name,
'type': 'team',
'role': 'owner',
'add_by': login_user.get('username'),
'created_at': time.time(),
}
result = Role.insert_one(role)
role['_id'] = result.inserted_id
role['team_id'] = data['_id']
role_ids = [str(role['_id'])]
# team_role = {
# 'role_id': result.inserted_id,
# 'team_id': role['team_id'],
# 'add_by': login_user.get('username'),
# 'created_at': time.time(),
# }
# Model.build_model('team_roles').insert_one(team_role)
for role_id in role_ids:
team_role = {
'$set': {
'team_id': team_id,
'role_id': role_id,
'created_at': time.time()
}
}
where = {
'team_id': team_id,
'role_id': role_id,
}
db.collection('team_roles').update_one(where, team_role, upsert=True)
Team().add_member(team_id, members, owner_id=login_user.get('user_id'))
return jsonify({
'message': 'ok',
'code': 0,
})
def edit_menu(_id):
params = request.get_json()
if not params:
return jsonify({'message': 'param required', 'code': 4000}), 400
is_admin = login_user.get('is_admin')
if not is_admin:
return jsonify({'message': 'permission deny', 'code': 104010}), 401
obj_id = ObjectId(_id)
record = db.collection('menus').find_one({'_id': obj_id})
if not record:
return jsonify({
'message': 'record not found',
'code': 104040
}), 404
name = params.get('name')
route = params.get('route')
icon = params.get('icon')
mpid = params.get('mpid')
bpid = params.get('bpid')
status = params.get('status', 1)
apis = params.get('apis') or []
update = {'apis': apis}
if name:
update['name'] = name
if route:
update['route'] = route
if icon:
update['icon'] = icon
if status is not None:
update['status'] = status
if mpid:
if int(mpid) > 0:
existed = db.collection('menus').find_one({'id': mpid})
if not existed:
return jsonify({
'message': 'invalid mpid',
'code': 104002
}), 400
elif mpid == record.get('id'):
return jsonify({
'message': 'invalid mpid',
'code': 104003
}), 400
update['mpid'] = str(mpid)
if bpid:
if int(bpid) > 0:
existed = db.collection('menus').find_one({'id': bpid})
if not existed:
return jsonify({
'message': 'invalid bpid',
'code': 104002
}), 400
elif bpid == record.get('id'):
return jsonify({
'message': 'invalid bpid',
'code': 104003
}), 400
update['bpid'] = str(bpid)
if update:
update['updated_at'] = datetime.datetime.now()
db.collection('menus').update_one({'_id': obj_id},
{'$set': update})
logger.info('update menu',
extra={
'record': record,
'change': update
})
return jsonify({
'message': 'ok',
'code': 0,
})
def explore():
payload = request.get_json()
form = request.form
payload = payload or form
if not payload:
return jsonify({
'message': 'empty request payload',
'code': 144000,
}), 400
explore_type = payload.get('type')
credential = payload.get('credential')
# if not credential:
# return jsonify({
# 'message': 'param credential required',
# 'code': 144000,
# }), 400
private_key = ''
if credential:
credential = Credential.find_by_id(credential)
if not credential or not credential.get('status'):
return jsonify({
'message': 'invalid credential',
'code': 144040,
}), 404
vault = Vault({'vault_pass': config.vault.get('secret')})
body = credential['body']
private_key = vault.decrypt_string(body[credential['type']])
maintainer = payload.get('maintainer')
if not maintainer or type(maintainer) != list:
maintainer = [login_user.get('username')]
else:
maintainer.extend(login_user.get('username'))
if explore_type == 'manual':
region = payload.get('region')
group = payload.get('group')
ssh_host = payload.get('ssh_host')
ssh_user = payload.get('ssh_user')
ssh_port = payload.get('ssh_port') or 22
if not ssh_host or not ssh_user or not ssh_port:
return jsonify({
'message': 'illegal ssh connection params',
'code': 144001,
}), 400
region_record = Region.find_one({'_id': ObjectId(region)})
if not region_record:
return jsonify({
'message': 'invalid region',
'code': 144002,
}), 400
group_record = Group.find_by_ids(group)
if not group_record:
return jsonify({
'message': 'invalid group',
'code': 144003,
}), 400
options = {
'remote_user': ssh_user,
'verbosity': 3,
}
hosts = ssh_host + ':' + str(ssh_port) + ','
runner = setup(hosts, options, private_key)
result = runner.get_result()
data = process_ansible_setup(result)
records = []
if not data:
return jsonify({
'code': 144009,
'message': 'fetch target host failed',
'data': result
}), 406
for item in data:
item['ansible_ssh_host'] = ssh_host
item['ansible_ssh_user'] = ssh_user
item['ansible_ssh_port'] = ssh_port
item['maintainer'] = maintainer
item['group'] = list(map(lambda i: str(i['_id']), group_record))
item['add_by'] = login_user.get('username')
item['state'] = 'active'
where = {'ansible_ssh_host': item['ansible_ssh_host']}
update = {'$set': item}
result = db.collection('machines').update_one(where,
update,
upsert=True)
extra = item.copy()
extra['_id'] = result.upserted_id
logger.info('add machines hostname: '.format({item['hostname']}),
extra={'record': data})
records.append(item)
# def func(item):
# item['ansible_ssh_host'] = ssh_host
# item['ansible_ssh_user'] = ssh_user
# item['ansible_ssh_port'] = ssh_port
# item['maintainer'] = maintainer
# item['group'] = list(map(lambda i: str(i['_id']), group_record))
# item['add_by'] = login_user.get('username')
# item['state'] = 'active'
#
# return item
#
# data = list(map(func, data))
# db.collection('machines').insert_many(data)
return jsonify({
'message': 'ok',
'code': 0,
'data': records,
'records': data
})
files = request.files
if not files:
return jsonify({
'message': 'illegal param',
'code': 104000,
}), 400
file = files.get('inventory')
if not files:
return jsonify({
'message': 'files required',
'code': 104001,
}), 400
sources = file.read().decode('utf-8')
# inventory is not only yaml
with NamedTemporaryFile('w+t', delete=True) as fd:
fd.write(sources)
fd.seek(0)
options = {
'verbosity': 0,
}
runner = setup(fd.name, options, private_key)
result = runner.get_result()
data = process_ansible_setup(result)
if not data:
return jsonify({
'code': 144009,
'message': 'fetch target host failed',
'data': result
}), 400
manager = runner.inventory
hosts = parser_inventory(manager)
records = []
default_region = db.collection('regions').find_one({'name': 'default'})
if not default_region:
result = db.collection('regions').insert_one({
'name':
'default',
'add_by':
None,
'description':
'auto generate',
'created_at':
time.time(),
})
region_id = str(result.inserted_id)
else:
region_id = str(default_region.get('_id'))
for node in data:
hostname = node.get('ansible_hostname')
for group, host in hosts.items():
where = {'name': group}
# insert_data = {'$set': insert_data}
existed = db.collection('groups').find_one(where)
if not existed:
insert_data = {
'name': group,
'region': region_id,
'description': 'auto generator',
'state': 'active',
'add_by': login_user.get('username'),
'maintainer': None,
'created_at': int(time.time())
}
insert_result = db.collection('groups').insert_one(
insert_data)
group = insert_result.inserted_id
else:
group = existed['_id']
if host.get('name') == hostname:
vars = host.get('vars')
node['ansible_ssh_host'] = vars.get('ansible_ssh_host')
node['ansible_ssh_user'] = vars.get(
'ansible_ssh_user', 'root')
node['ansible_ssh_port'] = vars.get(
'ansible_ssh_port', '22')
node['group'] = [group]
node['add_by'] = login_user.get('username')
node['state'] = 'active'
break
records.append(node)
for record in records:
where = {'ansible_ssh_host': record['ansible_ssh_host']}
update = {'$set': record}
result = db.collection('machines').update_one(where,
update,
upsert=True)
extra = record.copy()
extra['_id'] = result.upserted_id
logger.info('add machines hostname: '.format({record['hostname']}),
extra={'record': data})
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
'records': records,
})
def add_book():
params = request.get_json() or request.form
if not params:
return jsonify({
'message': 'invalid params',
'code': 154000,
}), 400
name = params.get('name')
if not name:
return jsonify({
'message': 'name param required',
'code': 154001,
}), 400
existed = Book.find_one({'name': name})
if existed:
return jsonify({
'message': 'book exist',
'code': 154003,
}), 400
description = params.get('description')
status = params.get('status', 0)
book_id = params.get('_id')
import_type = params.get('importType')
repo = params.get('repo')
maintainer = params.get('maintainer', [])
readonly = params.get('readonly', False)
if book_id:
record = Book.find_by_id(book_id)
if not record:
return jsonify({
'message': 'record not found',
'code': 154041,
}), 404
else:
data = {
'name': name,
'readonly': readonly,
'description': description,
'maintainer': maintainer,
'import_type': import_type,
'repo': repo,
'created_at': int(time.time())
}
result = Book.insert_one(data)
book_id = result.inserted_id
if import_type == 'galaxy' and repo:
galaxy = AnsibleGalaxy([repo])
galaxy.install(book_id)
logger.info('import galaxy', extra={'repo': repo})
elif import_type == 'git' and repo:
git = GitDownload({'repository': repo})
dest = git.install()
Workspace().import_book_from_dir(dest, book_id, exclude=['.git'])
data = {
'readonly': readonly,
'description': description,
'maintainer': maintainer,
'import_type': import_type,
'repo': repo,
'status': int(status),
'updated_at': time.time(),
}
Book.update_one({'_id': ObjectId(book_id)}, {'$set': data}, upsert=True)
data['_id'] = book_id
return jsonify({
'message': 'ok',
'code': 0,
'data': data,
})
