def save_project(request, project_id):
""" Save project properties """
if request.method != 'POST':
return res.get_only_post_allowed({})
project_entry = BluesteelProjectEntry.objects.filter(id=project_id).first()
if project_entry is None:
return res.get_response(404, 'Bluesteel project not found', {})
(json_valid, post_info) = val.validate_json_string(request.body)
if not json_valid:
return res.get_json_parser_failed({})
(obj_validated, val_resp_obj) = val.validate_obj_schema(post_info, BluesteelSchemas.SAVE_PROJECT)
if not obj_validated:
return res.get_schema_failed(val_resp_obj)
CommandSetEntry.objects.filter(group=project_entry.command_group).delete()
local_search_path = filter_folder_path(val_resp_obj['git_project_folder_search_path'])
project_entry.name = val_resp_obj['name']
project_entry.git_project_folder_search_path = local_search_path
project_entry.save()
CommandController.add_full_command_set(project_entry.command_group, 'CLONE', 0, val_resp_obj['clone'])
CommandController.add_full_command_set(project_entry.command_group, 'FETCH', 1, val_resp_obj['fetch'])
return res.get_response(200, 'Project saved', {})
def get_project_ids_and_names_from_layout(request, layout_id):
""" Return project ids, names and selected one from a layout """
if request.method != 'GET':
return res.get_only_get_allowed({})
layout = BluesteelLayoutEntry.objects.filter(id=layout_id).first()
if layout is None:
return res.get_response(400, 'Layout not found', {})
project_entries = BluesteelProjectEntry.objects.filter(
layout=layout).order_by('order')
projects = []
for index, project in enumerate(project_entries):
obj = {}
obj['id'] = project.id
obj['name'] = project.name
obj['selected'] = index == layout.project_index_path
projects.append(obj)
data = {}
data['projects'] = projects
return res.get_response(200, 'Layout projects info found', data)
def purge_old_feed_reports(request, worker_id, keep_young_count):
""" Purge old feed reports and keep young ones"""
if request.method != 'POST':
return res.get_response(400, 'Only post allowed', {})
GitFeederController.purge_old_reports(worker_id, keep_young_count)
return res.get_response(200, 'Feed reports purged', {})
def purge_all_feed_reports(request, worker_id):
""" Purge all feed reports """
if request.method != 'POST':
return res.get_response(400, 'Only post allowed', {})
GitFeederController.purge_all_reports(worker_id)
return res.get_response(200, 'Feed reports purged', {})
def delete_branches(request, project_id):
""" Delete all the branches associated with a project """
if request.method != 'POST':
return res.get_response(400, 'Only post allowed', {})
project_entry = GitProjectEntry.objects.filter(id=project_id).first()
if project_entry is None:
return res.get_response(404, 'project not found', {})
(json_valid, post_info) = val.validate_json_string(request.body)
if not json_valid:
LogEntry.error(
request.user,
'Json parser failed.\n{0}'.format(json.dumps(post_info)))
return res.get_json_parser_failed({})
(obj_validated, val_resp_obj) = val.validate_obj_schema(
post_info, GitFeederSchemas.GIT_FEED_DELETE_BRANCHES_SCHEMA)
if not obj_validated:
LogEntry.error(
request.user,
'Json schema failed.\n{0}'.format(json.dumps(val_resp_obj)))
return res.get_schema_failed(val_resp_obj)
for name in val_resp_obj['branch_names']:
GitFeederController.delete_branch(project_entry, name)
return res.get_response(200, 'Branches removed correctly', {})
def view_save_benchmark_definition(request, benchmark_definition_id):
""" Save benchmark definition properties """
if request.method != 'POST':
return res.get_only_post_allowed({})
(json_valid_value, post_info) = val.validate_json_string(request.body)
if not json_valid_value:
return res.get_json_parser_failed({})
(obj_validated, val_resp_obj) = val.validate_obj_schema(
post_info, BenchmarkDefinitionSchemas.SAVE_BENCHMARK_DEFINITION)
if not obj_validated:
return res.get_schema_failed(val_resp_obj)
bench_entry = BenchmarkDefinitionController.save_benchmark_definition(
benchmark_definition_id=benchmark_definition_id,
name=val_resp_obj['name'],
layout_id=val_resp_obj['layout_id'],
project_id=val_resp_obj['project_id'],
priority=val_resp_obj['priority'],
active=val_resp_obj['active'],
command_list=val_resp_obj['command_list'],
max_fluctuation_percent=val_resp_obj['max_fluctuation_percent'],
overrides=val_resp_obj['overrides'],
max_weeks_old_notify=val_resp_obj['max_weeks_old_notify'],
work_passes=val_resp_obj['work_passes'],
)
if bench_entry is None:
return res.get_response(404, 'Benchmark Defintion save error', {})
return res.get_response(200, 'Benchmark Definition saved', {})
def save_layout(request, layout_id):
""" Save layout properties """
if request.method != 'POST':
return res.get_only_post_allowed({})
layout_entry = BluesteelLayoutEntry.objects.filter(id=layout_id).first()
if layout_entry is None:
return res.get_response(404, 'Bluesteel layout not found', {})
(json_valid, post_info) = val.validate_json_string(request.body)
if not json_valid:
return res.get_json_parser_failed({})
(obj_validated,
val_resp_obj) = val.validate_obj_schema(post_info,
BluesteelSchemas.SAVE_LAYOUT)
if not obj_validated:
return res.get_schema_failed(val_resp_obj)
layout_entry.name = val_resp_obj['name']
layout_entry.active = val_resp_obj['active']
layout_entry.project_index_path = val_resp_obj['project_index_path']
# Check if change of path in case we need to purge other services like 'performance tests service'
layout_entry.clamp_project_index_path()
layout_entry.check_active_state()
layout_entry.save()
return res.get_response(200, 'Layout saved', {})
def post_feed_reports(request, project_id):
""" Insert feed reports to a given git project """
if request.method != 'POST':
return res.get_response(400, 'Only post allowed', {})
project_entry = GitProjectEntry.objects.filter(id=project_id).first()
if project_entry is None:
return res.get_response(404, 'project not found', {})
(json_valid, post_info) = val.validate_json_string(request.body)
if not json_valid:
LogEntry.error(
request.user,
'Json parser failed.\n{0}'.format(json.dumps(post_info)))
return res.get_json_parser_failed({})
(obj_validated, val_resp_obj) = val.validate_obj_schema(
post_info, GitFeederSchemas.GIT_FEED_REPORTS_SCHEMA)
if not obj_validated:
LogEntry.error(
request.user,
'Json schema failed.\n{0}'.format(json.dumps(val_resp_obj)))
return res.get_schema_failed(val_resp_obj)
GitFeederController.insert_reports(request.user, val_resp_obj['reports'],
project_entry)
if request.user.is_authenticated() and not request.user.is_anonymous():
worker_entry = WorkerEntry.objects.filter(user=request.user).first()
if worker_entry:
GitFeederController.purge_old_reports(
worker_entry.id, worker_entry.max_feed_reports)
return res.get_response(200, 'Reports added correctly', {})
def login_worker_info(request):
""" Makes login with worker credentials """
if request.method != 'POST':
return res.get_only_post_allowed({})
(json_valid, post_info) = val.validate_json_string(request.body)
if not json_valid:
return res.get_json_parser_failed({})
(obj_validated, obj) = val.validate_obj_schema(post_info, BluesteelWorkerSchemas.LOGIN_WORKER_SCHEMA)
if not obj_validated:
return res.get_schema_failed(obj)
user = authenticate(username=obj['username'], password=obj['password'])
if user is not None:
# the password verified for the user
if user.is_active:
login(request, user)
return res.get_response(200, 'Access granted!', {})
return res.get_response(200, 'The password is valid, but the account has been disabled!', {})
# the authentication system was unable to verify the username and password
return res.get_response(401, 'Access denied!', {})
def get_project_list_from_layout(request, layout_id):
""" Return project ids, names and get-branch-list url """
if request.method != 'GET':
return res.get_only_get_allowed({})
layout = BluesteelLayoutEntry.objects.filter(id=layout_id).first()
if layout is None:
return res.get_response(400, 'Layout not found', {})
project_entries = BluesteelProjectEntry.objects.filter(layout=layout).order_by('order')
projects = []
for project in project_entries:
obj = {}
obj['id'] = project.id
obj['name'] = project.name
obj['url'] = {}
obj['url']['project_branch_list'] = ViewUrlGenerator.get_project_branch_list_url(project.git_project.id)
obj['url']['project_definition_list'] = ViewUrlGenerator.get_project_definition_list_url(project.id)
projects.append(obj)
data = {}
data['projects'] = projects
return res.get_response(200, 'Projects info found', data)
def create_worker_info(request):
""" Creates a worker given its info """
if request.method != 'POST':
return res.get_only_post_allowed({})
(json_valid, post_info) = val.validate_json_string(request.body)
if not json_valid:
return res.get_json_parser_failed(
{}
)
(obj_validated, val_resp_obj) = val.validate_obj_schema(
post_info,
BluesteelWorkerSchemas.CREATE_WORKER_INFO_SCHEMA
)
if not obj_validated:
return res.get_schema_failed(val_resp_obj)
obj = val_resp_obj
username_trimmed = obj['uuid'][:30]
worker = WorkerEntry.objects.filter(uuid=username_trimmed).first()
if worker is not None:
return res.get_response(405, 'Worker already created', {})
user = User.objects.filter(username=username_trimmed).first()
if not user:
user = User.objects.create_user(
username=username_trimmed,
email=None,
password=obj['uuid']
)
user.save()
worker_count = WorkerEntry.objects.all().count()
new_worker = WorkerEntry.objects.create(
uuid=obj['uuid'],
name=obj['host_name'],
operative_system=obj['operative_system'],
user=user,
git_feeder=(worker_count == 0)
)
new_worker.save()
BenchmarkDefinitionController.populate_worker_passes_all_definitions()
ret = {}
ret['worker'] = new_worker.as_object()
ret['worker']['url'] = get_worker_urls(request.get_host(), ret['worker']['id'], ret['worker']['uuid'])
ret['worker']['last_update'] = str(ret['worker']['last_update'])
return res.get_response(200, 'Worker created succesfuly!', ret)
def update_worker_activity(request, worker_id):
""" Updates worker activity from the last update time """
if request.method != 'POST':
return res.get_only_post_allowed({})
worker = WorkerEntry.objects.filter(id=worker_id).first()
if worker:
worker.save()
return res.get_response(200, 'Acitivity updated', {})
return res.get_response(404, 'Worker not found!', {})
def get_worker_files_hash(request):
""" Returns the hash of all the files of the worker source code """
if request.method != 'GET':
return res.get_only_get_allowed({})
worker_files_hash = WorkerFilesHashEntry.objects.all().first()
if not worker_files_hash:
return res.get_response(400, 'Worker files hash not found', {})
obj = {}
obj['worker_files_hash'] = worker_files_hash.files_hash
return res.get_response(200, 'Worker files hash', obj)
def get_layout(request, layout_id):
""" Return layout in json """
if request.method != 'GET':
return res.get_only_get_allowed({})
layout = BluesteelLayoutEntry.objects.filter(id=layout_id).first()
if layout is None:
return res.get_response(400, 'Layout not found', {})
layout_obj = layout.as_object()
layout_obj = add_project_feed_url(request, layout_obj)
return res.get_response(200, 'Layout found', layout_obj)
def modify_fluctuation_waiver(request, waiver_id, value):
""" Modify the fluctuation waiver to allow or deny notifications. """
if request.method != 'POST':
return res.get_only_post_allowed({})
waiver = BenchmarkFluctuationWaiverEntry.objects.filter(
id=waiver_id).first()
if waiver is None:
return res.get_response(404, 'Waiver does not exists!', {})
waiver.notification_allowed = value
waiver.save()
return res.get_response(200, 'Waiver modified succesfully!', {})
def delete(request, layout_id):
""" Layout deletion """
if request.method != 'POST':
return res.get_only_post_allowed({})
layout_entry = BluesteelLayoutEntry.objects.filter(id=layout_id).first()
if layout_entry is None:
return res.get_response(404, 'Bluesteel layout not found', {})
BluesteelLayoutController.delete_layout(layout_entry)
data = {}
data['redirect'] = ViewUrlGenerator.get_layout_all_url(1)
return res.get_response(200, 'Layout deleted', data)
def delete_worker(request, worker_id):
""" Deletes worker and all its related info from BlueSteel """
if request.method != 'POST':
return res.get_only_post_allowed({})
worker = WorkerEntry.objects.filter(id=worker_id).first()
if worker is None:
return res.get_response(400, 'Worker not found', {})
else:
worker.delete()
obj = {}
obj['redirect'] = ViewUrlGenerator.get_worker_all_url(1)
return res.get_response(200, 'Worker Deleted!', obj)
def invalidate_benchmark_execution(request, benchmark_execution_id):
""" Check and save a benchmark execution data into the db """
if request.method == 'POST':
bench_exec_entry = BenchmarkExecutionEntry.objects.filter(
id=benchmark_execution_id).first()
if bench_exec_entry is None:
return res.get_response(404, 'Bench Execution Entry not found', {})
bench_exec_entry.invalidated = True
bench_exec_entry.save()
return res.get_response(200, 'Benchmark Execution invalidated', {})
else:
return res.get_response(400, 'Only post allowed', {})
def create_new_benchmark_definition(request):
""" Creates a new benchmark defintion """
if request.method != 'POST':
return res.get_response(400, 'Only post allowed', {})
definition = BenchmarkDefinitionController.create_default_benchmark_definition(
)
BenchmarkDefinitionController.populate_worker_passes_for_definition(
definition)
data = {}
data['redirect'] = ViewUrlGenerator.get_benchmark_definitions_url(1)
return res.get_response(200, 'Benchmark definition created', data)
def add_default_project(request, layout_id):
""" Add default projet to layout """
if request.method != 'POST':
return res.get_only_post_allowed({})
layout_entry = BluesteelLayoutEntry.objects.filter(id=layout_id).first()
if layout_entry is None:
return res.get_response(404, 'Bluesteel layout not found', {})
BluesteelLayoutController.add_default_project_to_layout(layout_entry)
BluesteelLayoutController.sort_layout_projects_by_order(layout_entry)
obj = {}
obj['redirect'] = ViewUrlGenerator.get_layout_edit_url(layout_entry.id)
return res.get_response(200, 'Layout saved!', obj)
def get_known_commit_hashes(request, project_id):
""" Returns a list of known commit hashes for a given project """
if request.method == 'GET':
project_entry = GitProjectEntry.objects.filter(id=project_id).first()
if project_entry is None:
return res.get_response(404, 'project not found', {})
obj = {}
obj['hashes'] = list(
GitCommitEntry.objects.filter(project=project_entry).values_list(
'commit_hash', flat=True))
return res.get_response(200, '', obj)
else:
return res.get_only_get_allowed({})
def get_bootstrap_urls(request):
""" Returns the bootstrap entry urls """
if request.method != 'GET':
return res.get_only_get_allowed({})
obj = get_entry_points_urls(request.get_host())
return res.get_response(200, 'Entry points', obj)
def view_duplicate_benchmark_definition(request, benchmark_definition_id):
""" Duplicate benchmark definition properties """
if request.method != 'POST':
return res.get_only_post_allowed({})
dup_bench_entry = BenchmarkDefinitionController.duplicate_benchmark_definition(
benchmark_definition_id)
if dup_bench_entry is None:
return res.get_response(404, 'Benchmark Defintion save error', {})
data = {}
data['redirect'] = ViewUrlGenerator.get_benchmark_definition_url(
dup_bench_entry.id)
return res.get_response(200, 'Benchmark Definition saved', data)
def view_delete_benchmark_definition(request, benchmark_definition_id):
""" Delete benchmark definition properties """
if request.method != 'POST':
return res.get_only_post_allowed({})
ret = BenchmarkDefinitionController.delete_benchmark_definition(
benchmark_definition_id=benchmark_definition_id)
data = {}
data['redirect'] = ViewUrlGenerator.get_benchmark_definitions_url(1)
data['benchmark_definition_id'] = benchmark_definition_id
if ret:
return res.get_response(200, 'Benchmark Defintion deleted', data)
return res.get_response(404, 'Benchmark Definition not found', data)
def acquire_benchmark_execution(request):
""" Acquire the next available benchmark execution posible """
if request.method != 'POST':
return res.get_only_post_allowed({})
BenchmarkExecutionController.try_populate_executions(
POPULATE_EXECUTIONS_INC_COUNT)
next_execution = BenchmarkExecutionController.get_earliest_available_execution(
request.user)
if next_execution is None:
return res.get_response(404, 'Next Execution not found', {})
execution = ViewPrepareObjects.prepare_benchmark_execution_for_html(
next_execution.as_object(), request.get_host())
return res.get_response(200, 'Next Execution', execution)
def wipe(request, layout_id):
""" Layout wipe data """
if request.method != 'POST':
return res.get_only_post_allowed({})
layout_entry = BluesteelLayoutEntry.objects.filter(id=layout_id).first()
if layout_entry is None:
return res.get_response(404, 'Bluesteel layout not found', {})
project_entries = BluesteelProjectEntry.objects.filter(layout=layout_entry)
for project in project_entries:
project.wipe_data()
data = {}
data['redirect'] = ViewUrlGenerator.get_layout_all_url(1)
return res.get_response(200, 'Layout wiped', data)
def send_notifications(request):
""" Sends all the stacked emails to notify users """
if request.method != 'POST':
return res.get_only_post_allowed({})
MailingController.MailingController.send_stacked_emails()
return res.get_response(200, 'Stacked emails sent', {})
def get_worker_info(request, worker_uuid):
""" Returns worker info based on uuid """
if request.method != 'GET':
return res.get_only_get_allowed({})
worker = WorkerEntry.objects.filter(uuid=worker_uuid).first()
obj = {}
obj['csrf_token'] = csrf.get_token(request)
if worker is None:
return res.get_response(400, 'Worker not found', obj)
ret_worker = worker.as_object()
ret_worker['last_update'] = str(ret_worker['last_update'])
ret_worker['url'] = get_worker_urls(request.get_host(), ret_worker['id'], ret_worker['uuid'])
obj['worker'] = ret_worker
return res.get_response(200, 'Worker found', obj)
def update_branch_order_value(request, branch_id, project_id, order_value):
""" Change branch order value """
if request.method == 'POST':
project_entry = GitProjectEntry.objects.filter(id=project_id).first()
if project_entry is None:
return res.get_response(404, 'project not found', {})
branch_entry = GitBranchEntry.objects.filter(project=project_entry,
id=branch_id).first()
if branch_entry is None:
return res.get_response(404, 'branch not found', {})
GitController.sort_branch_with_branches(project_entry, branch_entry,
order_value)
return res.get_response(200, 'Branch order saved', {})
else:
return res.get_only_post_allowed({})
def delete_project(request, project_id):
""" Delete project on a layout """
if request.method != 'POST':
return res.get_only_post_allowed({})
project_entry = BluesteelProjectEntry.objects.filter(id=project_id).first()
if project_entry is None:
return res.get_response(404, 'Bluesteel project not found', {})
layout_id = project_entry.layout.id
project_entry.layout.active = False
project_entry.layout.save()
BluesteelProjectController.delete_project(project_entry)
BluesteelLayoutController.sort_layout_projects_by_order(project_entry.layout)
obj = {}
obj['redirect'] = ViewUrlGenerator.get_layout_edit_url(layout_id)
return res.get_response(200, 'Project deleted', obj)
