def list(self, request):
"""Gets job executions and their associated job_type id, name, and version
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, 'status', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_category', required=False)
node_ids = rest_util.parse_int_list(request, 'node_id', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
job_exes = JobExecution.objects.get_exes(started, ended, job_status, job_type_ids, job_type_names,
job_type_categories, node_ids, order)
page = self.paginate_queryset(job_exes)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
'''Retrieves the product updates for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, u'started', required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
job_type_ids = rest_util.parse_int_list(request, u'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, u'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, u'job_type_category', required=False)
is_operational = rest_util.parse_bool(request, u'is_operational', required=False)
file_name = rest_util.parse_string(request, u'file_name', required=False)
order = rest_util.parse_string_list(request, u'order', required=False)
products = ProductFile.objects.get_products(started, ended, job_type_ids, job_type_names, job_type_categories,
is_operational, file_name, order)
page = rest_util.perform_paging(request, products)
ProductFile.objects.populate_source_ancestors(page)
serializer = ProductFileUpdateListSerializer(page, context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, name):
'''Retrieves the plot values for metrics and return them in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
choice_ids = rest_util.parse_string_list(request, 'choice_id', required=False)
column_names = rest_util.parse_string_list(request, 'column', required=False)
group_names = rest_util.parse_string_list(request, 'group', required=False)
try:
provider = registry.get_provider(name)
metrics_type = provider.get_metrics_type(include_choices=False)
except MetricsTypeError:
raise Http404
# Build a unique set of column names from groups
columns = metrics_type.get_column_set(column_names, group_names)
# Get the actual plot values
metrics_values = provider.get_plot_data(started, ended, choice_ids, columns)
page = rest_util.perform_paging(request, metrics_values)
if len(choice_ids) > 1:
serializer = MetricsPlotMultiListSerializer(page, context={'request': request})
else:
serializer = MetricsPlotListSerializer(page, context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request):
"""Retrieves jobs and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
statuses = rest_util.parse_string_list(request, 'status', required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_category', required=False)
error_categories = rest_util.parse_string_list(request, 'error_category', required=False)
include_superseded = rest_util.parse_bool(request, 'include_superseded', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = Job.objects.get_jobs(started=started, ended=ended, statuses=statuses, job_ids=job_ids,
job_type_ids=job_type_ids, job_type_names=job_type_names,
job_type_categories=job_type_categories, error_categories=error_categories,
include_superseded=include_superseded, order=order)
page = self.paginate_queryset(jobs)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Retrieves the list of all job types and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
names = rest_util.parse_string_list(request, 'name', required=False)
categories = rest_util.parse_string_list(request, 'category', required=False)
is_active = rest_util.parse_bool(request, 'is_active', default_value=True)
is_operational = rest_util.parse_bool(request, 'is_operational', required=False)
order = rest_util.parse_string_list(request, 'order', ['name', 'version'])
job_types = JobType.objects.get_job_types(started=started, ended=ended, names=names, categories=categories,
is_active=is_active, is_operational=is_operational, order=order)
page = self.paginate_queryset(job_types)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Retrieves the product updates for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, u'started', required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
job_type_ids = rest_util.parse_int_list(request, u'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, u'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, u'job_type_category', required=False)
is_operational = rest_util.parse_bool(request, u'is_operational', required=False)
file_name = rest_util.parse_string(request, u'file_name', required=False)
order = rest_util.parse_string_list(request, u'order', required=False)
products = ProductFile.objects.get_products(started, ended, job_type_ids, job_type_names, job_type_categories,
is_operational, file_name, order)
page = self.paginate_queryset(products)
ProductFile.objects.populate_source_ancestors(page)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
'''Gets job executions and their associated job_type id, name, and version
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, u'started', required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, u'status', required=False)
job_type_ids = rest_util.parse_int_list(request, u'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, u'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, u'job_type_category', required=False)
node_ids = rest_util.parse_int_list(request, u'node_id', required=False)
order = rest_util.parse_string_list(request, u'order', required=False)
job_exes = JobExecution.objects.get_exes(started, ended, job_status, job_type_ids, job_type_names,
job_type_categories, node_ids, order)
page = rest_util.perform_paging(request, job_exes)
serializer = JobExecutionListSerializer(page, context={u'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request):
"""Retrieves the job updates for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, 'status', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_category', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = Job.objects.get_job_updates(started, ended, job_status, job_type_ids, job_type_names,
job_type_categories, order)
page = self.paginate_queryset(jobs)
Job.objects.populate_input_files(page)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
'''Retrieves the job updates for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, u'started', required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, u'status', required=False)
job_type_ids = rest_util.parse_int_list(request, u'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, u'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, u'job_type_category', required=False)
order = rest_util.parse_string_list(request, u'order', required=False)
jobs = Job.objects.get_job_updates(started, ended, job_status, job_type_ids, job_type_names,
job_type_categories, order)
page = rest_util.perform_paging(request, jobs)
Job.objects.populate_input_files(page)
serializer = JobUpdateListSerializer(page, context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request):
'''Gets jobs and their associated latest execution
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, u'started', required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, u'status', required=False)
job_type_ids = rest_util.parse_int_list(request, u'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, u'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, u'job_type_category', required=False)
order = rest_util.parse_string_list(request, u'order', required=False)
jobs = Job.objects.get_jobs(started, ended, job_status, job_type_ids, job_type_names, job_type_categories,
order)
page = rest_util.perform_paging(request, jobs)
# Add the latest execution for each matching job
paged_jobs = list(page.object_list)
job_exes_dict = JobExecution.objects.get_latest(page.object_list)
for job in paged_jobs:
job.latest_job_exe = job_exes_dict[job.id] if job.id in job_exes_dict else None
page.object_list = paged_jobs
serializer = JobWithExecutionListSerializer(page, context={u'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request):
"""Retrieves the batches and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
statuses = rest_util.parse_string_list(request, 'status', required=False)
recipe_type_ids = rest_util.parse_int_list(request, 'recipe_type_id', required=False)
recipe_type_names = rest_util.parse_string_list(request, 'recipe_type_name', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
batches = Batch.objects.get_batches(started=started, ended=ended, statuses=statuses,
recipe_type_ids=recipe_type_ids, recipe_type_names=recipe_type_names,
order=order)
page = self.paginate_queryset(batches)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Gets jobs and their associated latest execution
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, 'status', required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_category', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = Job.objects.get_jobs(started, ended, job_status, job_ids, job_type_ids, job_type_names,
job_type_categories, order)
# Add the latest execution for each matching job
page = self.paginate_queryset(jobs)
job_exes_dict = JobExecution.objects.get_latest(page)
for job in page:
job.latest_job_exe = job_exes_dict[job.id] if job.id in job_exes_dict else None
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def test_parse_string_list_optional(self):
'''Tests parsing an optional list of string parameters that are missing.'''
request = MagicMock(Request)
request.QUERY_PARAMS = QueryDict('', mutable=True)
request.QUERY_PARAMS.setlist('test', ['value1'])
self.assertListEqual(rest_util.parse_string_list(request, 'test2', required=False), [])
def _get_v6(self, request):
"""Retrieves the list of all errors and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
is_builtin = rest_util.parse_bool(request, 'is_builtin', required=False)
job_type_name = rest_util.parse_string(request, 'job_type_name', required=False)
name = rest_util.parse_string(request, 'name', required=False)
category = rest_util.parse_string(request, 'category', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
errors = Error.objects.get_errors(started=started, ended=ended, order=order, is_builtin=is_builtin,
job_type_name=job_type_name, name=name, category=category)
page = self.paginate_queryset(errors)
serializer = self.serializer_class(page, many=True)
return self.get_paginated_response(serializer.data)
def _list_v6(self, request):
"""Retrieves the job load for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(
request, 'started', default_value=rest_util.get_relative_days(7))
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started,
ended,
max_duration=datetime.timedelta(days=31))
job_type_ids = rest_util.parse_int_list(request,
'job_type_id',
required=False)
job_type_names = rest_util.parse_string_list(request,
'job_type_name',
required=False)
job_loads = JobLoad.objects.get_job_loads(started, ended, job_type_ids,
job_type_names)
job_loads_grouped = JobLoad.objects.group_by_time(job_loads)
page = self.paginate_queryset(job_loads_grouped)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def test_parse_string_list_default(self):
'''Tests parsing a required list of string parameters that are provided via default value.'''
request = MagicMock(Request)
request.QUERY_PARAMS = QueryDict('', mutable=True)
request.QUERY_PARAMS.setlist('test', ['value1'])
self.assertEqual(rest_util.parse_string_list(request, 'test2', ['value2', 'value3']), ['value2', 'value3'])
def test_parse_string_list(self):
"""Tests parsing a required list of string parameters that is provided via GET."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertListEqual(rest_util.parse_string_list(request, 'test'), ['value1', 'value2'])
def test_parse_string_list_post(self):
'''Tests parsing a required list of string parameters that are provided via POST.'''
request = MagicMock(Request)
request.DATA = QueryDict('', mutable=True)
request.DATA.setlist('test', ['value1', 'value2'])
self.assertEqual(rest_util.parse_string_list(request, 'test'), ['value1', 'value2'])
def post(self, request, recipe_id):
"""Schedules a recipe for reprocessing and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:param recipe_id: The id of the recipe
:type recipe_id: int encoded as a str
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
job_names = rest_util.parse_string_list(request, 'job_names', required=False)
all_jobs = rest_util.parse_bool(request, 'all_jobs', required=False)
try:
handler = Recipe.objects.reprocess_recipe(recipe_id, job_names, all_jobs)
except Recipe.DoesNotExist:
raise Http404
except ReprocessError as err:
raise BadParameter(unicode(err))
try:
new_recipe = Recipe.objects.get_details(handler.recipe.id)
except Recipe.DoesNotExist:
raise Http404
url = urlresolvers.reverse('recipe_details_view', args=[new_recipe.id])
serializer = self.get_serializer(new_recipe)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=dict(location=url))
def list(self, request):
"""Retrieves the source file updates for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request,
u'started',
required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
is_parsed = rest_util.parse_bool(request, u'is_parsed', required=False)
file_name = rest_util.parse_string(request,
u'file_name',
required=False)
order = rest_util.parse_string_list(request, u'order', required=False)
sources = SourceFile.objects.get_sources(started, ended, is_parsed,
file_name, order)
page = self.paginate_queryset(sources)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list_v6(self, request):
"""Retrieves the list of all recipe types returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
keywords = rest_util.parse_string_list(request,
'keyword',
required=False)
is_active = rest_util.parse_bool(request, 'is_active', required=False)
is_system = rest_util.parse_bool(request, 'is_system', required=False)
order = ['name']
recipe_types = RecipeType.objects.get_recipe_types_v6(
keywords=keywords,
is_active=is_active,
is_system=is_system,
order=order)
page = self.paginate_queryset(recipe_types)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def _list_v6(self, request):
"""Retrieves a list of files based on filters and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
data_started = rest_util.parse_timestamp(request, 'data_started', required=False)
data_ended = rest_util.parse_timestamp(request, 'data_ended', required=False)
rest_util.check_time_range(data_started, data_ended)
source_started = rest_util.parse_timestamp(request, 'source_started', required=False)
source_ended = rest_util.parse_timestamp(request, 'source_ended', required=False)
rest_util.check_time_range(source_started, source_ended)
source_sensor_classes = rest_util.parse_string_list(request, 'source_sensor_class', required=False)
source_sensors = rest_util.parse_string_list(request, 'source_sensor', required=False)
source_collections = rest_util.parse_string_list(request, 'source_collection', required=False)
source_tasks = rest_util.parse_string_list(request, 'source_task', required=False)
mod_started = rest_util.parse_timestamp(request, 'modified_started', required=False)
mod_ended = rest_util.parse_timestamp(request, 'modified_ended', required=False)
rest_util.check_time_range(mod_started, mod_ended)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
file_names = rest_util.parse_string_list(request, 'file_name', required=False)
job_outputs = rest_util.parse_string_list(request, 'job_output', required=False)
recipe_ids = rest_util.parse_int_list(request, 'recipe_id', required=False)
recipe_type_ids = rest_util.parse_int_list(request, 'recipe_type_id', required=False)
recipe_nodes = rest_util.parse_string_list(request, 'recipe_node', required=False)
batch_ids = rest_util.parse_int_list(request, 'batch_id', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
files = ScaleFile.objects.filter_files(
data_started=data_started, data_ended=data_ended,
source_started=source_started, source_ended=source_ended,
source_sensor_classes=source_sensor_classes, source_sensors=source_sensors,
source_collections=source_collections, source_tasks=source_tasks,
mod_started=mod_started, mod_ended=mod_ended, job_type_ids=job_type_ids,
job_type_names=job_type_names, job_ids=job_ids,
file_names=file_names, job_outputs=job_outputs, recipe_ids=recipe_ids,
recipe_type_ids=recipe_type_ids, recipe_nodes=recipe_nodes, batch_ids=batch_ids,
order=order,
)
page = self.paginate_queryset(files)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def test_parse_string_list_optional(self):
"""Tests parsing an optional list of string parameters that are missing."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1'])
self.assertListEqual(
rest_util.parse_string_list(request, 'test2', required=False), [])
def test_parse_string_list(self):
"""Tests parsing a required list of string parameters that is provided via GET."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertListEqual(rest_util.parse_string_list(request, 'test'),
['value1', 'value2'])
def test_parse_string_list_accepted_all(self):
'''Tests parsing a list of string parameters where all values are acceptable.'''
request = MagicMock(Request)
request.QUERY_PARAMS = QueryDict('', mutable=True)
request.QUERY_PARAMS.setlist('test', ['value1', 'value2'])
self.assertListEqual(rest_util.parse_string_list(request, 'test', accepted_values=['value1', 'value2']),
['value1', 'value2'])
def test_parse_string_list_post(self):
"""Tests parsing a required list of string parameters that are provided via POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({'test': ['value1', 'value2']})
self.assertEqual(rest_util.parse_string_list(request, 'test'),
['value1', 'value2'])
def test_parse_string_list_post(self):
"""Tests parsing a required list of string parameters that are provided via POST."""
request = MagicMock(Request)
request.data = QueryDict('', mutable=True)
request.data.update({
'test': ['value1', 'value2']
})
self.assertEqual(rest_util.parse_string_list(request, 'test'), ['value1', 'value2'])
def list(self, request):
"""Retrieves the product updates for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_type_ids = rest_util.parse_int_list(request,
'job_type_id',
required=False)
job_type_names = rest_util.parse_string_list(request,
'job_type_name',
required=False)
job_type_categories = rest_util.parse_string_list(request,
'job_type_category',
required=False)
is_operational = rest_util.parse_bool(request,
'is_operational',
required=False)
file_name = rest_util.parse_string(request,
'file_name',
required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
products = ProductFile.objects.get_products(
started=started,
ended=ended,
job_type_ids=job_type_ids,
job_type_names=job_type_names,
job_type_categories=job_type_categories,
is_operational=is_operational,
file_name=file_name,
order=order)
page = self.paginate_queryset(products)
ProductFile.objects.populate_source_ancestors(page)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
"""Retrieves the job updates for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
statuses = rest_util.parse_string_list(request,
'status',
required=False)
job_type_ids = rest_util.parse_int_list(request,
'job_type_id',
required=False)
job_type_names = rest_util.parse_string_list(request,
'job_type_name',
required=False)
job_type_categories = rest_util.parse_string_list(request,
'job_type_category',
required=False)
include_superseded = rest_util.parse_bool(request,
'include_superseded',
required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = Job.objects.get_job_updates(
started=started,
ended=ended,
statuses=statuses,
job_type_ids=job_type_ids,
job_type_names=job_type_names,
job_type_categories=job_type_categories,
include_superseded=include_superseded,
order=order)
page = self.paginate_queryset(jobs)
Job.objects.populate_input_files(page)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list_impl(self, request, name):
"""Retrieves the plot values for metrics and return them in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:param name: the name of the metrics detail to retrieve.
:type name: string
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
choice_ids = rest_util.parse_string_list(request,
'choice_id',
required=False)
column_names = rest_util.parse_string_list(request,
'column',
required=False)
group_names = rest_util.parse_string_list(request,
'group',
required=False)
try:
provider = registry.get_provider(name)
metrics_type = provider.get_metrics_type(include_choices=False)
except MetricsTypeError:
raise Http404
# Build a unique set of column names from groups
columns = metrics_type.get_column_set(column_names, group_names)
# Get the actual plot values
metrics_values = provider.get_plot_data(started, ended, choice_ids,
columns)
page = self.paginate_queryset(metrics_values)
if len(choice_ids) > 1:
serializer = MetricsPlotMultiSerializer(page, many=True)
else:
serializer = MetricsPlotSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Gets jobs and their associated latest execution
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_statuses = rest_util.parse_string_list(request,
'status',
required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
job_type_ids = rest_util.parse_int_list(request,
'job_type_id',
required=False)
job_type_names = rest_util.parse_string_list(request,
'job_type_name',
required=False)
job_type_categories = rest_util.parse_string_list(request,
'job_type_category',
required=False)
error_categories = rest_util.parse_string_list(request,
'error_category',
required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = Job.objects.get_jobs(started, ended, job_statuses, job_ids,
job_type_ids, job_type_names,
job_type_categories, error_categories,
order)
# Add the latest execution for each matching job
page = self.paginate_queryset(jobs)
job_exes_dict = JobExecution.objects.get_latest(page)
for job in page:
job.latest_job_exe = job_exes_dict[
job.id] if job.id in job_exes_dict else None
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def test_parse_string_list_default(self):
'''Tests parsing a required list of string parameters that are provided via default value.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1'])
self.assertEqual(
rest_util.parse_string_list(request, 'test2',
['value2', 'value3']),
['value2', 'value3'])
def post(self, request):
"""Submit command message to re-queue jobs that fit the given filter criteria
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
error_categories = rest_util.parse_string_list(request, 'error_categories', required=False)
error_ids = rest_util.parse_int_list(request, 'error_ids', required=False)
job_ids = rest_util.parse_int_list(request, 'job_ids', required=False)
job_status = rest_util.parse_string(request, 'status', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_ids', required=False)
priority = rest_util.parse_int(request, 'priority', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_names', required=False)
batch_ids = rest_util.parse_int_list(request, 'batch_ids', required=False)
recipe_ids = rest_util.parse_int_list(request, 'recipe_ids', required=False)
is_superseded = rest_util.parse_bool(request, 'is_superseded', required=False)
job_types = rest_util.parse_dict_list(request, 'job_types', required=False)
for jt in job_types:
if 'name' not in jt or 'version' not in jt:
raise BadParameter('Job types argument invalid: %s' % job_types)
existing_job_type = JobType.objects.filter(name=jt['name'], version=jt['version']).first()
if not existing_job_type:
raise BadParameter(
'Job Type with name: %s and version: %s does not exist' % (jt['name'], jt['version']))
job_type_ids.append(existing_job_type.id)
# Create and send message
msg = create_requeue_jobs_bulk_message(started=started, ended=ended, error_categories=error_categories,
error_ids=error_ids, job_ids=job_ids, job_type_ids=job_type_ids,
priority=priority, status=job_status, job_type_names=job_type_names,
batch_ids=batch_ids, recipe_ids=recipe_ids, is_superseded=is_superseded)
CommandMessageManager().send_messages([msg])
return Response(status=status.HTTP_202_ACCEPTED)
def post(self, request):
"""Increase max_tries, place it on the queue, and returns the new job information in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, 'status', required=False)
job_ids = rest_util.parse_int_list(request, 'job_ids', required=False)
job_type_ids = rest_util.parse_int_list(request,
'job_type_ids',
required=False)
job_type_names = rest_util.parse_string_list(request,
'job_type_names',
required=False)
job_type_categories = rest_util.parse_string_list(
request, 'job_type_categories', required=False)
priority = rest_util.parse_int(request, 'priority', required=False)
# Fetch all the jobs matching the filters
jobs = Job.objects.get_jobs(started, ended, job_status, job_ids,
job_type_ids, job_type_names,
job_type_categories)
if not jobs:
raise Http404
# Attempt to queue all jobs matching the filters
requested_job_ids = {job.id for job in jobs}
Queue.objects.requeue_jobs(requested_job_ids, priority)
# Refresh models to get the new status information for all originally requested jobs
jobs = Job.objects.get_jobs(job_ids=requested_job_ids)
page = self.paginate_queryset(jobs)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def test_parse_string_list_accepted_all(self):
"""Tests parsing a list of string parameters where all values are acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertListEqual(
rest_util.parse_string_list(request,
'test',
accepted_values=['value1', 'value2']),
['value1', 'value2'])
def list_v6(self, request, job_id):
"""Gets job executions and their associated job_type id, name, and version
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
statuses = rest_util.parse_string_list(request, 'status', required=False)
node_ids = rest_util.parse_int_list(request, 'node_id', required=False)
error_ids = rest_util.parse_int_list(request, 'error_id', required=False)
error_cats = rest_util.parse_string_list(request, 'error_category', required=False)
job_exes = JobExecution.objects.get_job_exes(job_id=job_id, statuses=statuses, node_ids=node_ids,
error_ids=error_ids, error_categories=error_cats)
page = self.paginate_queryset(job_exes)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list_impl(self, request, source_id=None):
"""Retrieves the jobs for a given source file ID and returns them in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:param source_id: The id of the source
:type source_id: int encoded as a string
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
try:
ScaleFile.objects.get(id=source_id, file_type='SOURCE')
except ScaleFile.DoesNotExist:
raise Http404
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
statuses = rest_util.parse_string_list(request, 'status', required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_category', required=False)
batch_ids = rest_util.parse_int_list(request, 'batch_id', required=False)
error_categories = rest_util.parse_string_list(request, 'error_category', required=False)
include_superseded = rest_util.parse_bool(request, 'include_superseded', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = SourceFile.objects.get_source_jobs(source_id, started=started, ended=ended, statuses=statuses,
job_ids=job_ids, job_type_ids=job_type_ids,
job_type_names=job_type_names,
job_type_categories=job_type_categories, batch_ids=batch_ids,
error_categories=error_categories,
include_superseded=include_superseded, order=order)
page = self.paginate_queryset(jobs)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Retrieves jobs and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
source_started = rest_util.parse_timestamp(request, 'source_started', required=False)
source_ended = rest_util.parse_timestamp(request, 'source_ended', required=False)
rest_util.check_time_range(source_started, source_ended)
source_sensor_classes = rest_util.parse_string_list(request, 'source_sensor_class', required=False)
source_sensors = rest_util.parse_string_list(request, 'source_sensor', required=False)
source_collections = rest_util.parse_string_list(request, 'source_collection', required=False)
source_tasks = rest_util.parse_string_list(request, 'source_task', required=False)
statuses = rest_util.parse_string_list(request, 'status', required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
batch_ids = rest_util.parse_int_list(request, 'batch_id', required=False)
recipe_ids = rest_util.parse_int_list(request, 'recipe_id', required=False)
error_categories = rest_util.parse_string_list(request, 'error_category', required=False)
error_ids = rest_util.parse_int_list(request, 'error_id', required=False)
is_superseded = rest_util.parse_bool(request, 'is_superseded', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = Job.objects.get_jobs_v6(started=started, ended=ended,
source_started=source_started, source_ended=source_ended,
source_sensor_classes=source_sensor_classes, source_sensors=source_sensors,
source_collections=source_collections, source_tasks=source_tasks,
statuses=statuses, job_ids=job_ids,
job_type_ids=job_type_ids, job_type_names=job_type_names,
batch_ids=batch_ids, recipe_ids=recipe_ids,
error_categories=error_categories, error_ids=error_ids,
is_superseded=is_superseded, order=order)
# additional optimizations not being captured by the existing ones in the manager
# see issue #1717
jobs = jobs.select_related('job_type_rev__job_type').defer(None)
page = self.paginate_queryset(jobs)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request, source_id=None):
"""Retrieves the ingests for a given source file ID and returns them in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:param source_id: The id of the source
:type source_id: int encoded as a string
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
try:
ScaleFile.objects.get(id=source_id, file_type='SOURCE')
except ScaleFile.DoesNotExist:
raise Http404
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
ingest_statuses = rest_util.parse_string_list(request,
'status',
required=False)
strike_ids = rest_util.parse_int_list(request,
'strike_id',
required=False)
scan_ids = rest_util.parse_int_list(request, 'scan_id', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
ingests = SourceFile.objects.get_source_ingests(
source_id,
started=started,
ended=ended,
statuses=ingest_statuses,
scan_ids=scan_ids,
strike_ids=strike_ids,
order=order)
page = self.paginate_queryset(ingests)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
'''Retrieves the list of all recipes and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
type_ids = rest_util.parse_int_list(request, 'type_id', required=False)
type_names = rest_util.parse_string_list(request, 'type_name', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
recipes = Recipe.objects.get_recipes(started, ended, type_ids, type_names, order)
page = rest_util.perform_paging(request, recipes)
serializer = RecipeListSerializer(page, context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request):
"""Retrieves the list of all workspaces and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, "started", required=False)
ended = rest_util.parse_timestamp(request, "ended", required=False)
rest_util.check_time_range(started, ended)
names = rest_util.parse_string_list(request, "name", required=False)
order = rest_util.parse_string_list(request, "order", ["name"])
workspaces = Workspace.objects.get_workspaces(started, ended, names, order)
page = self.paginate_queryset(workspaces)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
"""Retrieves the list of all workspaces and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
names = rest_util.parse_string_list(request, 'name', required=False)
order = rest_util.parse_string_list(request, 'order', ['name'])
workspaces = Workspace.objects.get_workspaces(started, ended, names, order)
page = self.paginate_queryset(workspaces)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Retrieves jobs and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_statuses = rest_util.parse_string_list(request,
'status',
required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
job_type_ids = rest_util.parse_int_list(request,
'job_type_id',
required=False)
job_type_names = rest_util.parse_string_list(request,
'job_type_name',
required=False)
job_type_categories = rest_util.parse_string_list(request,
'job_type_category',
required=False)
error_categories = rest_util.parse_string_list(request,
'error_category',
required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
jobs = Job.objects.get_jobs(started, ended, job_statuses, job_ids,
job_type_ids, job_type_names,
job_type_categories, error_categories,
order)
page = self.paginate_queryset(jobs)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def post(self, request):
"""Increase max_tries, place it on the queue, and returns the new job information in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_status = rest_util.parse_string(request, 'status', required=False)
job_ids = rest_util.parse_int_list(request, 'job_ids', required=False)
job_type_ids = rest_util.parse_int_list(request, 'job_type_ids', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_names', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_categories', required=False)
error_categories = rest_util.parse_string_list(request, 'error_categories', required=False)
priority = rest_util.parse_int(request, 'priority', required=False)
# Fetch all the jobs matching the filters
job_status = [job_status] if job_status else job_status
jobs = Job.objects.get_jobs(started=started, ended=ended, statuses=job_status, job_ids=job_ids,
job_type_ids=job_type_ids, job_type_names=job_type_names,
job_type_categories=job_type_categories, error_categories=error_categories)
if not jobs:
raise Http404
# Attempt to queue all jobs matching the filters
requested_job_ids = {job.id for job in jobs}
Queue.objects.requeue_jobs(requested_job_ids, priority)
# Refresh models to get the new status information for all originally requested jobs
jobs = Job.objects.get_jobs(job_ids=requested_job_ids)
page = self.paginate_queryset(jobs)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
'''Retrieves the list of all job types and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, u'started', required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
names = rest_util.parse_string_list(request, u'name', required=False)
categories = rest_util.parse_string_list(request, u'category', required=False)
order = rest_util.parse_string_list(request, u'order', [u'name', u'version'])
job_types = JobType.objects.get_job_types(started, ended, names, categories, order)
page = rest_util.perform_paging(request, job_types)
serializer = JobTypeListSerializer(page, context={u'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request):
"""Retrieves the list of all job types and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
names = rest_util.parse_string_list(request, 'name', required=False)
categories = rest_util.parse_string_list(request,
'category',
required=False)
is_active = rest_util.parse_bool(request,
'is_active',
default_value=True)
is_operational = rest_util.parse_bool(request,
'is_operational',
required=False)
order = rest_util.parse_string_list(request, 'order',
['name', 'version'])
job_types = JobType.objects.get_job_types(
started=started,
ended=ended,
names=names,
categories=categories,
is_active=is_active,
is_operational=is_operational,
order=order)
page = self.paginate_queryset(job_types)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Retrieves the list of all recipes and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
type_ids = rest_util.parse_int_list(request, 'type_id', required=False)
type_names = rest_util.parse_string_list(request, 'type_name', required=False)
include_superseded = rest_util.parse_bool(request, 'include_superseded', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
recipes = Recipe.objects.get_recipes(started=started, ended=ended, type_ids=type_ids, type_names=type_names,
include_superseded=include_superseded, order=order)
page = self.paginate_queryset(recipes)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request):
"""Gets job executions and their associated job_type id, name, and version
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
job_statuses = rest_util.parse_string_list(request,
'status',
required=False)
job_type_ids = rest_util.parse_int_list(request,
'job_type_id',
required=False)
job_type_names = rest_util.parse_string_list(request,
'job_type_name',
required=False)
job_type_categories = rest_util.parse_string_list(request,
'job_type_category',
required=False)
node_ids = rest_util.parse_int_list(request, 'node_id', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
job_exes = JobExecution.objects.get_exes(started, ended, job_statuses,
job_type_ids, job_type_names,
job_type_categories, node_ids,
order)
page = self.paginate_queryset(job_exes)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list(self, request, name):
"""Retrieves the plot values for metrics and return them in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:param name: the name of the metrics detail to retrieve.
:type name: string
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
choice_ids = rest_util.parse_string_list(request, 'choice_id', required=False)
column_names = rest_util.parse_string_list(request, 'column', required=False)
group_names = rest_util.parse_string_list(request, 'group', required=False)
try:
provider = registry.get_provider(name)
metrics_type = provider.get_metrics_type(include_choices=False)
except MetricsTypeError:
raise Http404
# Build a unique set of column names from groups
columns = metrics_type.get_column_set(column_names, group_names)
# Get the actual plot values
metrics_values = provider.get_plot_data(started, ended, choice_ids, columns)
page = self.paginate_queryset(metrics_values)
if len(choice_ids) > 1:
serializer = MetricsPlotMultiSerializer(page, many=True)
else:
serializer = MetricsPlotSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list_v6(self, request):
"""Retrieves a list of files based on filters and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
time_field = rest_util.parse_string(request, 'time_field', required=False,
accepted_values=ScaleFile.VALID_TIME_FIELDS)
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_ids = rest_util.parse_int_list(request, 'job_id', required=False)
file_names = rest_util.parse_string_list(request, 'file_name', required=False)
job_outputs = rest_util.parse_string_list(request, 'job_output', required=False)
recipe_ids = rest_util.parse_int_list(request, 'recipe_id', required=False)
recipe_type_ids = rest_util.parse_int_list(request, 'recipe_type_id', required=False)
recipe_nodes = rest_util.parse_string_list(request, 'recipe_node', required=False)
batch_ids = rest_util.parse_int_list(request, 'batch_id', required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
files = ScaleFile.objects.filter_files(
started=started, ended=ended, time_field=time_field, job_type_ids=job_type_ids,
job_type_names=job_type_names, job_ids=job_ids,
file_names=file_names, job_outputs=job_outputs, recipe_ids=recipe_ids,
recipe_type_ids=recipe_type_ids, recipe_nodes=recipe_nodes, batch_ids=batch_ids, order=order,
)
page = self.paginate_queryset(files)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def list_impl(self, request):
"""Retrieves the list of all ingests and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
ingest_statuses = rest_util.parse_string_list(request,
'status',
required=False)
strike_ids = rest_util.parse_int_list(request,
'strike_id',
required=False)
scan_ids = rest_util.parse_int_list(request, 'scan_id', required=False)
file_name = rest_util.parse_string(request,
'file_name',
required=False)
order = rest_util.parse_string_list(request, 'order', required=False)
ingests = Ingest.objects.get_ingests(started=started,
ended=ended,
statuses=ingest_statuses,
scan_ids=scan_ids,
strike_ids=strike_ids,
file_name=file_name,
order=order)
page = self.paginate_queryset(ingests)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
"""Retrieves the job load for a given time range and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', default_value=rest_util.get_relative_days(7))
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended, max_duration=datetime.timedelta(days=31))
job_type_ids = rest_util.parse_int_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_category', required=False)
job_type_priorities = rest_util.parse_string_list(request, 'job_type_priority', required=False)
job_loads = JobLoad.objects.get_job_loads(started, ended, job_type_ids, job_type_names, job_type_categories,
job_type_priorities)
job_loads_grouped = JobLoad.objects.group_by_time(job_loads)
page = rest_util.perform_paging(request, job_loads_grouped)
serializer = JobLoadGroupListSerializer(page, context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def create_v6(self, request):
"""Creates or edits a dataset and returns a link to the detail URL
:param request: the HTTP POST request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
title = rest_util.parse_string(request, 'title', required=False)
description = rest_util.parse_string(request,
'description',
required=False)
definition = rest_util.parse_dict(request, 'definition', required=True)
media_type = rest_util.parse_string_list(request,
'media_type',
required=False)
# validate the definition
try:
dataset_def = DataSetDefinitionV6(
definition=definition, do_validate=True).get_definition()
except InvalidDataSetDefinition as ex:
message = 'DataSet definition is invalid'
logger.exception(message)
raise BadParameter('%s: %s' % (message, unicode(ex)))
try:
dataset = DataSet.objects.create_dataset_v6(
dataset_def, title=title, description=description)
except Exception as ex:
message = 'Unable to create new dataset'
logger.exception(message)
raise BadParameter('%s: %s' % (message, unicode(ex)))
try:
dataset = DataSet.objects.get_details_v6(dataset.id)
except DataSet.DoesNotExist:
raise Http404
url = reverse('dataset_details_view',
args=[dataset.id],
request=request)
serializer = DataSetDetailsSerializerV6(dataset)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=dict(location=url))
def get(self, request):
"""Retrieves the list of all recipe types returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
order = rest_util.parse_string_list(request, 'order', ['name', 'version'])
recipe_types = RecipeType.objects.get_recipe_types(started, ended, order)
page = self.paginate_queryset(recipe_types)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
'''Retrieves the list of all nodes and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
include_inactive = rest_util.parse_bool(request, 'include_inactive', False, False)
order = rest_util.parse_string_list(request, 'order', required=False)
nodes = Node.objects.get_nodes(started, ended, order, include_inactive=include_inactive)
page = rest_util.perform_paging(request, nodes)
serializer = NodeListSerializer(page, context={'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request):
"""Retrieves the list of all nodes and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
started = rest_util.parse_timestamp(request, 'started', required=False)
ended = rest_util.parse_timestamp(request, 'ended', required=False)
rest_util.check_time_range(started, ended)
include_inactive = rest_util.parse_bool(request, 'include_inactive', False, False)
order = rest_util.parse_string_list(request, 'order', required=False)
nodes = Node.objects.get_nodes(started, ended, order, include_inactive=include_inactive)
page = self.paginate_queryset(nodes)
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
def get(self, request):
"""Exports the job and recipe configuration and returns it in JSON form.
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
"""
# Filter and export recipe types
recipe_type_ids = rest_util.parse_string_list(request, 'recipe_type_id', required=False)
recipe_type_names = rest_util.parse_string_list(request, 'recipe_type_name', required=False)
recipe_filter = recipe_type_ids or recipe_type_names
recipe_types = exporter.get_recipe_types(recipe_type_ids, recipe_type_names)
# Filter and export job types
job_type_ids = rest_util.parse_string_list(request, 'job_type_id', required=False)
job_type_names = rest_util.parse_string_list(request, 'job_type_name', required=False)
job_type_categories = rest_util.parse_string_list(request, 'job_type_category', required=False)
job_filter = job_type_ids or job_type_names or job_type_categories
job_types = exporter.get_job_types(recipe_types if recipe_filter else None, job_type_ids, job_type_names,
job_type_categories)
# Filter and export errors
error_ids = rest_util.parse_string_list(request, 'error_id', required=False)
error_names = rest_util.parse_string_list(request, 'error_name', required=False)
errors = exporter.get_errors(job_types if job_filter or recipe_filter else None, error_ids, error_names)
# Includes are handled at the very end so that the cascaded filtering works as expected
includes = rest_util.parse_string_list(
request, 'include', default_value=['recipe_types', 'job_types', 'errors'], required=False,
accepted_values=['recipe_types', 'job_types', 'errors']
)
recipe_types = recipe_types if 'recipe_types' in includes else None
job_types = job_types if 'job_types' in includes else None
errors = errors if 'errors' in includes else None
export_config = exporter.export_config(recipe_types, job_types, errors)
return Response(export_config.get_dict())
def get(self, request):
'''Retrieves the list of all errors and returns it in JSON form
:param request: the HTTP GET request
:type request: :class:`rest_framework.request.Request`
:rtype: :class:`rest_framework.response.Response`
:returns: the HTTP response to send back to the user
'''
started = rest_util.parse_timestamp(request, u'started', required=False)
ended = rest_util.parse_timestamp(request, u'ended', required=False)
rest_util.check_time_range(started, ended)
order = rest_util.parse_string_list(request, u'order', required=False)
errors = Error.objects.get_errors(started, ended, order)
page = rest_util.perform_paging(request, errors)
serializer = ErrorListSerializer(page, context={u'request': request})
return Response(serializer.data, status=status.HTTP_200_OK)