def get_all_results_from_jobs(user, j_id):
"""Get all results from job.
"""
job = v1_utils.verify_existence_and_get(j_id, _TABLE)
# If it's an admin or belongs to the same team
if not(auth.is_admin(user) or auth.is_in_team(user, job['team_id'])):
raise auth.UNAUTHORIZED
swift = dci_config.get_store('files')
job_files = json.loads(files.get_all_files(j_id).response[0])['files']
r_files = [file for file in job_files
if file['mime'] == 'application/junit']
results = []
for file in r_files:
file_path = swift.build_file_path(file['team_id'],
j_id,
file['id'])
content_file = swift.get_object(file_path)
data = tsfm.junit2dict(content_file)
results.append({'filename': file['name'],
'name': file['name'],
'total': data['total'],
'failures': data['failures'],
'errors': data['errors'],
'skips': data['skips'],
'time': data['time'],
'success': data['success'],
'testscases': data['testscases']})
return flask.jsonify({'results': results,
'_meta': {'count': len(results)}})
def delete_job_by_id(user, j_id):
# get If-Match header
if_match_etag = utils.check_and_get_etag(flask.request.headers)
job = v1_utils.verify_existence_and_get(j_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, job['team_id'])):
raise auth.UNAUTHORIZED
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.id == j_id,
_TABLE.c.etag == if_match_etag)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Job', j_id)
for model in [models.FILES]:
query = model.update().where(model.c.job_id == j_id).values(
**values
)
flask.g.db_conn.execute(query)
return flask.Response(None, 204, content_type='application/json')
def put_api_secret(user, r_id):
# get If-Match header
if_match_etag = utils.check_and_get_etag(flask.request.headers)
remoteci = v1_utils.verify_existence_and_get(r_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, remoteci['team_id'])):
raise auth.UNAUTHORIZED
where_clause = sql.and_(
_TABLE.c.etag == if_match_etag,
_TABLE.c.id == r_id,
)
values = {'api_secret': signature.gen_secret(), 'etag': utils.gen_etag()}
query = (_TABLE.update().where(where_clause).values(**values))
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIConflict('RemoteCI', r_id)
res = flask.jsonify(({
'id': r_id,
'etag': values['etag'],
'api_secret': values['api_secret']
}))
res.headers.add_header('ETag', values['etag'])
return res
def create_remotecis(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.remoteci.post(flask.request.json))
# If it's not a super admin nor belongs to the same team_id
if not (auth.is_admin(user)
or auth.is_in_team(user, values.get('team_id'))):
raise auth.UNAUTHORIZED
values.update({
'data': values.get('data', {}),
# XXX(fc): this should be populated as a default value from the
# model, but we don't return values from the database :(
'api_secret': signature.gen_secret(),
})
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError:
raise dci_exc.DCICreationConflict(_TABLE.name, 'name')
return flask.Response(json.dumps({'remoteci': values}),
201,
headers={'ETag': values['etag']},
content_type='application/json')
def put_remoteci(user, r_id):
# get If-Match header
if_match_etag = utils.check_and_get_etag(flask.request.headers)
values = schemas.remoteci.put(flask.request.json)
remoteci = v1_utils.verify_existence_and_get(r_id, _TABLE)
if 'data' in values:
remoteci_data = get_remoteci_data_json(user, r_id)
remoteci_data.update(values['data'])
values['data'] = {k: v for k, v in remoteci_data.items() if v}
if not (auth.is_admin(user) or auth.is_in_team(user, remoteci['team_id'])):
raise auth.UNAUTHORIZED
values['etag'] = utils.gen_etag()
where_clause = sql.and_(_TABLE.c.etag == if_match_etag,
_TABLE.c.state != 'archived', _TABLE.c.id == r_id)
query = (_TABLE.update().where(where_clause).values(**values))
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIConflict('RemoteCI', r_id)
return flask.Response(None,
204,
headers={'ETag': values['etag']},
content_type='application/json')
def verify_user_in_team(user, team_id):
"""Verify that the user belongs to a given team. If the user is an
admin then it belongs to all teams."""
if auth.is_admin(user):
return
if not auth.is_in_team(user, team_id):
raise dci_exc.DCIException('User\'s team does not belongs to '
'team %s.' % team_id,
status_code=412)
def delete_jobstate_by_id(user, js_id):
jobstate = v1_utils.verify_existence_and_get(js_id, _TABLE)
if not(auth.is_admin(user) or auth.is_in_team(user, jobstate['team_id'])):
raise auth.UNAUTHORIZED
where_clause = _TABLE.c.id == js_id
query = _TABLE.delete().where(where_clause)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Jobstate', js_id)
return flask.Response(None, 204, content_type='application/json')
def update_job_by_id(user, job_id):
"""Update a job
"""
# get If-Match header
if_match_etag = utils.check_and_get_etag(flask.request.headers)
# get the diverse parameters
values = schemas.job.put(flask.request.json)
job = v1_utils.verify_existence_and_get(job_id, _TABLE)
# If it's an admin or belongs to the same team
if not(auth.is_admin(user) or auth.is_in_team(user, job['team_id'])):
raise auth.UNAUTHORIZED
# Update jobstate if needed
status = values.get('status')
if status and job.status != status:
jobstates.insert_jobstate(user, {
'status': status,
'job_id': job_id
})
where_clause = sql.and_(_TABLE.c.etag == if_match_etag,
_TABLE.c.id == job_id)
values['etag'] = utils.gen_etag()
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIConflict('Job', job_id)
if values.get('status') == "failure":
_TEAMS = models.TEAMS
where_clause = sql.expression.and_(
_TEAMS.c.id == job['team_id']
)
query = (sql.select([_TEAMS]).where(where_clause))
team_info = flask.g.db_conn.execute(query).fetchone()
if team_info['notification'] is True:
if team_info['email'] is not None:
msg = {'event': 'notification',
'email': team_info['email'],
'job_id': str(job['id'])}
flask.g.sender.send_json(msg)
return flask.Response(None, 204, headers={'ETag': values['etag']},
content_type='application/json')
def get_all_tests(user, team_id):
args = schemas.args(flask.request.args.to_dict())
if not (auth.is_admin(user) or auth.is_in_team(user, team_id)):
raise auth.UNAUTHORIZED
query = v1_utils.QueryBuilder(_TABLE, args, _T_COLUMNS)
query.add_extra_condition(_TABLE.c.team_id == team_id)
query.add_extra_condition(_TABLE.c.state != 'archived')
# get the number of rows for the '_meta' section
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'tests': rows, '_meta': {'count': nb_rows}})
def delete_file_by_id(user, file_id):
file = v1_utils.verify_existence_and_get(file_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, file['team_id'])):
raise auth.UNAUTHORIZED
values = {'state': 'archived'}
where_clause = _TABLE.c.id == file_id
with flask.g.db_conn.begin():
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('File', file_id)
files_events.create_event(file_id, models.FILES_DELETE)
return flask.Response(None, 204, content_type='application/json')
def delete_test_by_id(user, t_id):
test = v1_utils.verify_existence_and_get(t_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, test['team_id'])):
raise auth.UNAUTHORIZED
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = _TABLE.c.id == t_id
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Test', t_id)
for model in [models.FILES]:
query = model.update().where(model.c.test_id == t_id).values(
**values)
flask.g.db_conn.execute(query)
return flask.Response(None, 204, content_type='application/json')
def get_file_content(user, file_id):
file = v1_utils.verify_existence_and_get(file_id, _TABLE)
swift = dci_config.get_store('files')
def get_object(swift_object):
for block in swift.get(swift_object)[1]:
yield block
if not (auth.is_admin(user) or auth.is_in_team(user, file['team_id'])):
raise auth.UNAUTHORIZED
file_path = swift.build_file_path(file['team_id'], file['job_id'], file_id)
# Check if file exist on the storage engine
swift.head(file_path)
filename = file['name'].replace(' ', '_')
headers = {
'Content-Length': file['size'],
'Content-Disposition': 'attachment; filename="%s"' % filename
}
return flask.Response(get_object(file_path),
content_type=file['mime'] or 'text/plain',
headers=headers)
def create_jobs(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.job.post(flask.request.json))
components_ids = values.pop('components')
values['team_id'] = values.get('team_id', user['team_id'])
# Only super admin can create job for other teams
if not auth.is_admin(user):
if not auth.is_in_team(user, values['team_id']):
raise auth.UNAUTHORIZED
values.update({
'status': 'new',
'configuration': {},
'user_agent': flask.request.environ.get('HTTP_USER_AGENT'),
'client_version': flask.request.environ.get(
'HTTP_CLIENT_VERSION'
),
})
# create the job and feed the jobs_components table
with flask.g.db_conn.begin():
query = _TABLE.insert().values(**values)
flask.g.db_conn.execute(query)
jobs_components_to_insert = []
for cmpt_id in components_ids:
v1_utils.verify_existence_and_get(cmpt_id, models.COMPONENTS)
jobs_components_to_insert.append({'job_id': values['id'],
'component_id': cmpt_id})
if jobs_components_to_insert:
flask.g.db_conn.execute(models.JOIN_JOBS_COMPONENTS.insert(),
jobs_components_to_insert)
return flask.Response(json.dumps({'job': values}), 201,
headers={'ETag': values['etag']},
content_type='application/json')
def delete_meta(user, j_id, m_id):
job = v1_utils.verify_existence_and_get(j_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, job['team_id'])):
raise auth.UNAUTHORIZED
return metas.delete_meta(j_id, m_id)
def get_all_metas(user, j_id):
job = v1_utils.verify_existence_and_get(j_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, job['team_id'])):
raise auth.UNAUTHORIZED
return metas.get_all_metas_from_job(j_id)
def get_jobdefinitions_by_test(user, test_id):
test = v1_utils.verify_existence_and_get(test_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, test['team_id'])):
raise auth.UNAUTHORIZED
return jobdefinitions.get_all_jobdefinitions(test['id'])
def get_team_by_id(user, t_id):
team = v1_utils.verify_existence_and_get(t_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, team['id'])):
raise auth.UNAUTHORIZED
return base.get_resource_by_id(user, team, _TABLE, _EMBED_MANY)
def get_test_by_id(user, t_id):
test = v1_utils.verify_existence_and_get(t_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, test['team_id'])):
raise auth.UNAUTHORIZED
res = flask.jsonify({'test': test})
return res