def get_task_history():
query = request.args or {}
page = int(query.get('page', 1))
size = int(query.get('pageSize', 50))
skip = (page - 1) * size
keyword = query.get('keyword')
where = {}
if keyword:
where['name'] = keyword
cursor = db.collection('tasks').find(where, skip=skip, limit=size)
total = cursor.count()
tasks = []
job = Job()
for task in cursor:
job_id = task.get('job_id')
if not job_id:
continue
task['job'] = job.find_by_id(job_id)
tasks.append(task)
return jsonify({
'message': 'ok',
'code': 0,
'data': {
'list': tasks,
'total': total,
'page': page,
'pageSize': size,
}
})
def gitlab_job(token):
payload = request.get_json()
object_type = payload.get('object_type')
tag = payload.get('tag')
job_id = payload.get('job_id')
project_id = payload.get('project_id')
job_status = payload.get('job_status')
repository = payload.get('repository')
record = Job().collection.find_one({'token': token})
if not record:
return jsonify({'message': 'invalid token', 'code': 104010}), 401
if object_type != 'job':
return jsonify({
'message': 'only job event allow',
'code': 104031
}), 403
if not job_id or not project_id or job_status != 'success':
return jsonify({'message': 'invalid params', 'code': 104000}), 400
if not tag:
return jsonify({'message': 'only tag allow', 'code': 104032}), 403
app_info = db.collection('apps').find_one(
{'_id': ObjectId(record.get('app_id'))})
if not app_info:
return jsonify({
'message': 'job must be bind with gitlab app',
'code': 104002
}), 400
params = app_info.get('params') or {}
if params.get('project_id') != project_id:
return jsonify({'message': 'illegal project', 'code': 104003}), 400
# if params.get('extract') == 'artifacts':
# wk = Workspace()
# filename = wk.get_gitlab_artifacts_file(record.get('name'), project_id, job_id)
# gitlab = GitlabApi().dowload_artifact(project_id, job_id, filename)
#
# if params.get('extract') == 'docker':
# pass
integration = Integration(app_info.get('type'), params)
integration.install()
ansible_params = load_ansible_playbook(record)
if ansible_params.get('message') is not 'ok':
return jsonify(payload), 400
data = ansible_params.get('data')
wk = Workspace()
res = wk.load_book_from_db(name=data.get('book_name'),
roles=data.get('roles'))
if not res:
return jsonify({
'message': 'load book failed',
'code': 104000,
}), 400
return jsonify({'message': 'ok', 'code': 0, 'data': 1})
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 = Job().collection.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 rollback(_id):
record = db.collection('tasks').find_one({'_id': ObjectId(_id)})
if not record:
return jsonify({
'message': 'task not found',
'code': 194041
}), 404
job_id = record.get('job_id')
if not job_id:
return jsonify({
'message': 'invalid job',
'code': 1040011
}), 400
where = {
'_id': ObjectId(job_id),
'status': 1,
}
job_record = Job().collection.find_one(where)
if not job_record:
return jsonify({
'message': 'invalid job',
'code': 1040010
}), 400
history = db.collection('build_history').find_one({'task_id': _id})
if not history:
return jsonify({
'message': 'failed load playbook from history',
'code': 104041
}), 404
build_id = str(history.get('_id'))
run_job(job_id, build_id)
return jsonify({
'message': 'ok',
'code': 0,
})
def job_webhook():
query = request.args
token = query.get('token')
payload = request.get_json()
if not payload or not token:
return jsonify({'message': 'invalid params', 'code': 104000}), 400
record = Job().collection.find_one({'token': token})
if not record:
return jsonify({'message': 'illegal token', 'code': 104010}), 401
if record.get('type') == 'adhoc':
task_id = run_job(str(record.get('_id')))
if not task_id:
return jsonify({
'message': 'try to queue task faield',
'code': 104008
}), 400
return jsonify({'message': 'ok', 'code': 0, 'data': task_id})
template = record.get('template')
app_id = template.get('app')
income_params = {'cache': True}
if app_id:
app_info = Application.find_by_id(app_id)
if not app_info:
return jsonify({
'message': 'app not found, please check your app',
'code': 104001
}), 400
app_params = app_info.get('params')
income = app_params.get('income')
if income and payload.get('income'):
income = Template(income)
tpl = income.render(**payload.get('income'))
tpl = yaml.safe_load(tpl)
if tpl:
income_params.update(tpl)
task_id = run_job(str(record.get('_id')), **income_params)
if not task_id:
return jsonify({
'message': 'put job enqueue failed',
'code': 104002
}), 400
# if app_type == 'jenkins':
# build_id = '19'
# job_name = 'upward'
# run_job(_id, job_name, build_id)
# elif app_type == 'gitlab':
# project_id = '13539397'
# job_id = '261939258'
# run_job(_id, project_id, job_id)
# else:
# run_job(_id)
# logger.error('test', extra={'a': {'b': 1}})
return jsonify({'message': 'ok', 'code': 0, 'data': task_id})
def test_add_adhoc_job(self, parse_cmdb_inventory,
get_credential_content_by_id, adhoc_runner):
data = self.get_data('adhoc_job')
data['name'] = str(uuid.uuid4())
url = self.get_api_path('/jobs')
response = self.client.post(url, data='{}', headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 104000)
params = data.copy()
# None module params should response 400
params['module'] = None
params['type'] = 'adhoc'
current_user = self.user
params['maintainer'] = [current_user.get('username')]
payload = self.body(params)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 104002)
# test parse_cmdb_inventory return None
parse_cmdb_inventory.return_value = None
params['module'] = 'ls'
payload = self.body(params)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 104004)
# test with check and no private_key condition
params['check'] = True
params['private_key'] = None
parse_cmdb_inventory.return_value = 'localhost'
runner_instance = adhoc_runner.return_value
runner_instance.get_result.return_value = data['name']
payload = self.body(params)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert200(response)
runner_instance.run.assert_called()
# test run with private_key
params['private_key'] = True
get_credential_content_by_id.return_value = None
payload = self.body(params)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 104004)
# assume get private_key return correct
get_credential_content_by_id.return_value = 'test-private'
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert200(response)
runner_instance.run.assert_called()
params['check'] = False
payload = self.body(params)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert200(response)
runner_instance.run.assert_called()
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert400(response)
record = Job.find_one({'name': data['name']})
assert record
assert record.get('name') == data.get('name')
params['job_id'] = str(ObjectId())
payload = self.body(params)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert404(response)
self.assertResponseCode(response, 104040)
params['job_id'] = str(record.get('_id'))
payload = self.body(params)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert200(response)
Job().collection.delete_one({'name': data['name']})
def test_add_job(self, load_ansible_playbook, workspace, key_mock, runner):
data = self.get_data('playbook_job')
data['name'] = str(uuid.uuid4())
url = self.get_api_path('/jobs')
response = self.client.post(url, data='{}', headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 104000)
params = data.copy()
params['type'] = 'playbook'
payload = self.body(params)
load_ansible_playbook.return_value = {'message': 'test', 'code': 123}
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 123)
options = {}
ansible_payload = {
'message': 'ok',
'code': 0,
'data': {
'inventory': options.get('inventory'),
'options': options,
'name': data.get('name'),
'entry': data['entry'],
'book_id': data.get('book_id'),
'book_name': 'test',
'roles': ['test'],
'inventory_type': 'cmdb',
'private_key': True,
'template': {},
'extra': {},
'status': 1,
}
}
load_ansible_playbook.return_value = ansible_payload
instance = workspace.return_value
instance.load_book_from_db.return_value = False
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 104000)
instance.load_book_from_db.return_value = True
instance.get_book_entry.return_value = '/dev/null'
params['check'] = True
params['private_key'] = True
payload = self.body(params)
key_mock.return_value = 'test_private_key'
instance = runner.return_value
instance.get_result.return_value = 'f**k'
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert200(response)
params['check'] = False
payload = self.body(params)
instance.get_result.return_value = 'f**k'
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert200(response)
response = self.client.post(url,
data=payload,
headers=self.jwt_headers)
self.assert400(response)
self.assertResponseCode(response, 104001)
Job().collection.delete_one({'name': data['name']})
