def upload(self, request):
if not settings.QUERY_UPLOAD:
raise Http404
serializer = QueryJobUploadSerializer(data=request.data,
context={
'request': request,
'view': self
})
serializer.is_valid(raise_exception=True)
file_name = handle_file_upload(
get_user_upload_directory(self.request.user),
serializer.validated_data['file'])
job = QueryJob(job_type=QueryJob.JOB_TYPE_INTERFACE,
owner=(None if self.request.user.is_anonymous else
self.request.user),
run_id=serializer.validated_data.get('run_id'),
table_name=serializer.validated_data.get('table_name'),
client_ip=get_client_ip(self.request))
job.process(upload=True)
job.save()
job.ingest(file_name)
serializer = QueryJobRetrieveSerializer(instance=job)
return Response(serializer.data)
def perform_sync_job(self, request, data):
# create the job objects
job = self.get_queryset().model(
job_type=Job.JOB_TYPE_SYNC,
owner=(None
if self.request.user.is_anonymous else self.request.user),
response_format=data.get('RESPONSEFORMAT'),
max_records=data.get('MAXREC'),
run_id=data.get('RUNID'),
client_ip=get_client_ip(self.request))
# add parameters to the job object
for parameter, model_field in self.parameter_map.items():
value = data.get(parameter)
if value is not None:
setattr(job, model_field, value)
# handle possible uploads
try:
self.handle_upload(job, data.get('UPLOAD'))
except ValueError:
raise ValidationError('Could not parse VOTable')
try:
job.process()
except ValidationError as e:
raise ValidationError(self.rewrite_exception(e))
return FileResponse(job.run_sync(),
content_type=job.formats[job.response_format])
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
# create the job objects
job = self.get_queryset().model(
job_type=Job.JOB_TYPE_ASYNC,
owner=(None
if self.request.user.is_anonymous else self.request.user),
response_format=serializer.validated_data.get('RESPONSEFORMAT'),
max_records=serializer.validated_data.get('MAXREC'),
# uploads=handle_uploads(request, serializer.validated_data.get('UPLOAD'), self.get_upload_directory()),
run_id=serializer.validated_data.get('RUNID'),
client_ip=get_client_ip(self.request))
# add parameters to the job object
for parameter, model_field in self.parameter_map.items():
value = serializer.validated_data.get(parameter)
if value is not None:
setattr(job, model_field, value)
# handle possible uploads
self.handle_upload(job, serializer.validated_data.get('UPLOAD'))
try:
job.process()
except ValidationError as e:
raise ValidationError(self.rewrite_exception(e))
job.save()
if serializer.validated_data.get('PHASE') == job.PHASE_RUN:
job.run()
return HttpResponseSeeOther(self.get_success_url(job))
def create(self, request):
try:
archive_job = ArchiveJob.objects.filter_by_owner(
request.user).get(data=request.data)
# check if the file was lost
if archive_job.phase == archive_job.PHASE_COMPLETED and \
not os.path.isfile(archive_job.file_path):
# set the phase back to pending so that the file is recreated
archive_job.phase = archive_job.PHASE_PENDING
archive_job.process()
archive_job.save()
archive_job.run()
except ArchiveJob.DoesNotExist:
archive_job = ArchiveJob(
owner=(None if self.request.user.is_anonymous else
self.request.user),
client_ip=get_client_ip(self.request),
data=request.data)
archive_job.process()
archive_job.save()
archive_job.run()
return Response({'id': archive_job.id})
def create_archive(self, request, pk=None):
try:
job = self.get_queryset().get(pk=pk)
except QueryJob.DoesNotExist:
raise NotFound
column_name = request.data.get('column_name')
try:
archive_job = QueryArchiveJob.objects.get(job=job,
column_name=column_name)
# check if the file was lost
if archive_job.phase == archive_job.PHASE_COMPLETED and \
not os.path.isfile(archive_job.file_path):
# set the phase back to pending so that the file is recreated
archive_job.phase = archive_job.PHASE_PENDING
archive_job.process()
archive_job.save()
archive_job.run()
except QueryArchiveJob.DoesNotExist:
archive_job = QueryArchiveJob(job_type=QueryJob.JOB_TYPE_INTERFACE,
client_ip=get_client_ip(
self.request),
job=job,
column_name=column_name)
archive_job.process()
archive_job.save()
archive_job.run()
return Response({'id': archive_job.id})
def create_download(self, request, pk=None):
try:
job = self.get_queryset().get(pk=pk)
except QueryJob.DoesNotExist:
raise NotFound
format_key = request.data.get('format_key')
try:
download_job = DownloadJob.objects.get(job=job,
format_key=format_key)
# check if the file was lost
if download_job.phase == download_job.PHASE_COMPLETED and \
not os.path.isfile(download_job.file_path):
# set the phase back to pending so that the file is recreated
download_job.phase = download_job.PHASE_PENDING
download_job.process()
download_job.save()
download_job.run()
except DownloadJob.DoesNotExist:
download_job = DownloadJob(job_type=QueryJob.JOB_TYPE_INTERFACE,
client_ip=get_client_ip(self.request),
job=job,
format_key=format_key)
download_job.process()
download_job.save()
download_job.run()
return Response({'id': download_job.id})
def send_file(request, file_path, search=None):
# create a stats record for this download
resource = {'file_path': file_path}
if search:
resource['search'] = search
Record.objects.create(
time=now(),
resource_type='FILE',
resource=resource,
client_ip=get_client_ip(request),
user=request.user if request.user.is_authenticated else None)
# send the file to the client
absolute_file_path = os.path.join(settings.FILES_BASE_PATH, file_path)
return sendfile(request, absolute_file_path)
def perform_create(self, serializer):
job = QueryJob(job_type=QueryJob.JOB_TYPE_INTERFACE,
owner=(None if self.request.user.is_anonymous else
self.request.user),
run_id=serializer.data.get('run_id'),
table_name=serializer.data.get('table_name'),
query_language=serializer.data.get('query_language'),
query=serializer.data.get('query'),
queue=serializer.data.get('queue'),
client_ip=get_client_ip(self.request))
job.process()
job.save()
job.run()
# inject the job id into the serializers data
serializer._data['id'] = job.id
def create_download(self, request, pk=None, download_key=None):
try:
job = self.get_queryset().get(pk=pk)
except QueryJob.DoesNotExist:
raise NotFound
download_config = get_download_config(download_key)
if download_config is None:
raise ValidationError({
'download':
'Download key "{}" is not supported.'.format(download_key)
})
download_job_model = import_class(download_config['model'])
params = {
param: request.data.get(param)
for param in download_config.get('params', [])
}
try:
download_job = download_job_model.objects.get(query_job=job,
**params)
# check if the file was lost
if download_job.phase == download_job.PHASE_COMPLETED and \
not os.path.isfile(download_job.file_path):
# set the phase back to pending so that the file is recreated
download_job.phase = download_job.PHASE_PENDING
download_job.process()
download_job.save()
download_job.run()
except download_job_model.DoesNotExist:
download_job = download_job_model(
job_type=QueryJob.JOB_TYPE_INTERFACE,
owner=(None if self.request.user.is_anonymous else
self.request.user),
client_ip=get_client_ip(self.request),
query_job=job,
**params)
download_job.process()
download_job.save()
download_job.run()
return Response({'id': download_job.id})
def retrieve(self, request, pk=None):
# get database adapter
adapter = DatabaseAdapter()
# get the schema_name and the table_name from the settings
schema_name = settings.ARCHIVE_SCHEMA
table_name = settings.ARCHIVE_TABLE
# get collecions for this user
collections = [
collection.name for collection in
Collection.objects.filter_by_access_level(request.user)
]
# fetch the path for this file from the database
row = adapter.fetch_row(schema_name,
table_name, ['path'],
filters={
'id': pk,
'collection': collections
})
if row:
if request.GET.get('download', True):
# create a stats record for this download
Record.objects.create(time=now(),
resource_type='ARCHIVE_DOWNLOAD',
resource=row[0],
client_ip=get_client_ip(request),
user=request.user if
request.user.is_authenticated else None)
# send the file to the client
file_path = os.path.join(settings.ARCHIVE_BASE_PATH, row[0])
return sendfile(request, file_path, attachment=True)
else:
# send an empty response
return Response()
# if the file was not found, return 404
raise NotFound()
