def create_meta(user, job_id):
"""Create a meta information associated to a specific job."""
v1_utils.verify_existence_and_get(job_id, models.JOBS)
values = v1_utils.common_values_dict(user)
values.update(schemas.meta.post(flask.request.json))
values.update({
'job_id': job_id
})
with flask.g.db_conn.begin():
where_clause = sql.and_(
_TABLE.c.name == values['name'],
_TABLE.c.job_id == values['job_id'])
query = sql.select([_TABLE.c.id]).where(where_clause)
if flask.g.db_conn.execute(query).fetchone():
raise dci_exc.DCIConflict('Meta already exists', values['name'])
# create the label/value row
query = _TABLE.insert().values(**values)
flask.g.db_conn.execute(query)
result = json.dumps({'meta': values})
return flask.Response(result, 201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_configuration(user, r_id):
values_configuration = v1_utils.common_values_dict(user)
values_configuration.update(
schemas.rconfiguration.post(flask.request.json))
values_configuration.update(flask.request.json)
remoteci = v1_utils.verify_existence_and_get(r_id, _TABLE)
if not user.is_in_team(remoteci['team_id']):
raise auth.UNAUTHORIZED
rconfiguration_id = values_configuration.get('id')
with flask.g.db_conn.begin():
try:
# insert configuration
query = _RCONFIGURATIONS.insert().\
values(**values_configuration)
flask.g.db_conn.execute(query)
# insert join between rconfiguration and remoteci
values_join = {
'rconfiguration_id': rconfiguration_id,
'remoteci_id': r_id}
query = models.JOIN_REMOTECIS_RCONFIGURATIONS.insert().\
values(**values_join)
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError as ie:
raise dci_exc.DCIException('Integrity Error: %s' % str(ie))
return flask.Response(
json.dumps({'rconfiguration': values_configuration}), 201,
headers={'ETag': values_configuration['etag']},
content_type='application/json'
)
def create_feeders(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.feeder.post(flask.request.json))
if not user.is_in_team(values['team_id']):
raise auth.UNAUTHORIZED
values.update({
# 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(),
'role_id': auth.get_role_id('FEEDER'),
'data': values.get('data', {}),
})
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({'feeder': values}),
201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_feeders(user):
values = flask.request.json
check_json_is_valid(create_feeder_schema, values)
values.update(v1_utils.common_values_dict())
if user.is_not_epm() and user.is_not_super_admin():
raise dci_exc.Unauthorized()
values.update({
# 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(),
'data': values.get('data', {}),
})
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({'feeder': values}),
201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_users(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.user.post(flask.request.json))
if not (auth.is_admin(user)
or auth.is_admin_user(user, values['team_id'])):
raise auth.UNAUTHORIZED
role_id = values.get('role_id', auth.get_role_id('USER'))
if not auth.is_admin(user) and role_id == auth.get_role_id('SUPER_ADMIN'):
raise auth.UNAUTHORIZED
values.update({
'password': auth.hash_password(values.get('password')),
'role_id': role_id
})
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError:
raise dci_exc.DCICreationConflict(_TABLE.name, 'name')
# remove the password in the result for security reasons
del values['password']
return flask.Response(json.dumps({'user': values}),
201,
headers={'ETag': values['etag']},
content_type='application/json')
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 create_users(user):
values = flask.request.json
check_json_is_valid(create_user_schema, values)
values.update(v1_utils.common_values_dict())
if user.is_not_super_admin():
raise dci_exc.Unauthorized()
values.update({
'password': auth.hash_password(values.get('password')),
'fullname': values.get('fullname', values['name']),
'timezone': values.get('timezone', 'UTC'),
'sso_username': None
})
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError:
raise dci_exc.DCICreationConflict(_TABLE.name, 'name')
# remove the password in the result for security reasons
del values['password']
return flask.Response(json.dumps({'user': values}),
201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_topics(user):
values = flask.request.json
check_json_is_valid(create_topic_schema, values)
values.update(v1_utils.common_values_dict())
if user.is_not_super_admin() and user.is_not_epm() and user.is_not_feeder(
): # noqa
raise dci_exc.Unauthorized()
# todo(yassine): enabled when client updated.
# if values['component_types'] == []:
# raise dci_exc.DCIException('component_types should not be void')
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError:
raise dci_exc.DCICreationConflict(_TABLE.name, 'name')
result = json.dumps({'topic': values})
return flask.Response(result,
201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_jobs(user):
values = flask.request.json
check_json_is_valid(create_job_schema, values)
values.update(v1_utils.common_values_dict())
components_ids = values.pop('components')
if user.is_not_remoteci():
raise dci_exc.DCIException('Only remoteci can create job')
topic_id = values.get('topic_id')
topic = v1_utils.verify_existence_and_get(topic_id, models.TOPICS)
export_control.verify_access_to_topic(user, topic)
previous_job_id = values.get('previous_job_id')
if previous_job_id:
v1_utils.verify_existence_and_get(previous_job_id, _TABLE)
values.update({
'status':
'new',
'remoteci_id':
user.id,
'topic_id':
topic_id,
'user_agent':
flask.request.environ.get('HTTP_USER_AGENT'),
'client_version':
flask.request.environ.get('HTTP_CLIENT_VERSION'),
'previous_job_id':
previous_job_id,
'team_id':
user.teams_ids[0],
'product_id':
topic['product_id'],
'duration':
0
})
# 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 create_tests(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.test.post(flask.request.json))
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({'test': values}),
201,
content_type='application/json')
def create_components(user):
if not auth.is_admin(user):
raise auth.UNAUTHORIZED
values = v1_utils.common_values_dict(user)
values.update(schemas.component.post(flask.request.json))
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError:
raise dci_exc.DCICreationConflict(_TABLE.name, 'name')
result = json.dumps({'component': values})
return flask.Response(result, 201, content_type='application/json')
def create_components(user):
values = flask.request.json
check_json_is_valid(create_component_schema, values)
values.update(v1_utils.common_values_dict())
if str(values['topic_id']) not in v1_utils.user_topic_ids(user):
raise dci_exc.Unauthorized()
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError:
raise dci_exc.DCICreationConflict(_TABLE.name, 'name')
result = json.dumps({'component': values})
return flask.Response(result, 201, content_type='application/json')
def create_jobdefinitions(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.jobdefinition.post(flask.request.json))
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError as e:
raise dci_exc.DCIException("Integrity error on 'test_id' field.",
payload=str(e))
result = json.dumps({'jobdefinition': values})
return flask.Response(result,
201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_roles(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.role.post(flask.request.json))
if not values['label']:
values.update({'label': values['name'].upper()})
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({'role': values}),
201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_teams(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.team.post(flask.request.json))
if not auth.is_admin(user):
raise auth.UNAUTHORIZED
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({'team': values}),
201,
headers={'ETag': values['etag']},
content_type='application/json')
def create_teams(user):
values = flask.request.json
check_json_is_valid(create_team_schema, values)
values.update(v1_utils.common_values_dict())
if user.is_not_super_admin() and user.is_not_epm():
raise dci_exc.Unauthorized()
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({'team': values}), 201,
headers={'ETag': values['etag']}, content_type='application/json'
)
def create_tests(user):
values = flask.request.json
check_json_is_valid(create_test_schema, values)
values.update(v1_utils.common_values_dict())
# todo: remove team_id
if 'team_id' in values:
del values['team_id']
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({'test': values}),
201,
content_type='application/json')
def create_teams(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.team.post(flask.request.json))
if not values['parent_id'] or \
(user.is_product_owner() and values['parent_id'] != user.team_id):
values['parent_id'] = user.team_id
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({'team': values}), 201,
headers={'ETag': values['etag']}, content_type='application/json'
)
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 user.is_super_admin() and not user.is_in_team(values['team_id']):
raise auth.UNAUTHORIZED
if values['topic_id'] is not None:
v1_utils.verify_team_in_topic(user, values['topic_id'])
values.update({
'status': 'new',
'topic_id': values['topic_id'],
'rconfiguration_id': values['rconfiguration_id'],
'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 create_topics(user):
values = v1_utils.common_values_dict(user)
values.update(schemas.topic.post(flask.request.json))
if not user.is_super_admin() and \
not ((user.is_product_owner() or user.is_feeder()) and
user.product_id == values['product_id']):
raise auth.UNAUTHORIZED
# todo(yassine): enabled when client updated.
# if values['component_types'] == []:
# raise dci_exc.DCIException('component_types should not be void')
query = _TABLE.insert().values(**values)
try:
flask.g.db_conn.execute(query)
except sa_exc.IntegrityError:
raise dci_exc.DCICreationConflict(_TABLE.name, 'name')
result = json.dumps({'topic': values})
return flask.Response(result, 201, headers={'ETag': values['etag']},
content_type='application/json')
def _get_or_create_issue(data):
values = v1_utils.common_values_dict()
values.update(data)
if 'github.com' in values['url']:
type = 'github'
else:
type = 'bugzilla'
values['tracker'] = type
# First, insert the issue if it doesn't already exist
# in the issues table. If it already exists, ignore the
# exceptions, and keep proceeding.
query = _TABLE.insert().returning(*_TABLE.columns).values(**values)
try:
return flask.g.db_conn.execute(query).fetchone()
except sa_exc.IntegrityError:
# It is not a real failure it the issue have been tried
# to inserted a second time. As long as it is once, we are
# good to proceed
query = (sql.select([_TABLE]).where(
sql.and_(_TABLE.c.url == values['url'],
_TABLE.c.topic_id == values['topic_id'])))
return flask.g.db_conn.execute(query).fetchone()
