def reclaim(self, request):
"""
Triggers an asynchronous space reclaim operation.
"""
serializer = ReclaimSpaceSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
repos = serializer.validated_data.get("repo_hrefs", [])
keeplist = serializer.validated_data.get("repo_versions_keeplist", [])
reclaim_repo_pks = []
keeplist_rv_pks = []
for repo in repos:
reclaim_repo_pks.append(repo.pk)
for rv in keeplist:
repos.append(rv.repository)
keeplist_rv_pks.append(rv.pk)
task = dispatch(
reclaim_space,
shared_resources=repos,
kwargs={
"repo_pks": reclaim_repo_pks,
"keeplist_rv_pks": keeplist_rv_pks,
},
)
return OperationPostponedResponse(task, request)
def post(self, request, path):
"""
Queues a task that creates a new Collection from an uploaded artifact.
"""
distro = get_object_or_404(AnsibleDistribution, base_path=path)
serializer = GalaxyCollectionUploadSerializer(
data=request.data, context={"request": request})
serializer.is_valid(raise_exception=True)
expected_digests = {"sha256": serializer.validated_data["sha256"]}
artifact = Artifact.init_and_validate(
serializer.validated_data["file"],
expected_digests=expected_digests)
artifact.save()
locks = [str(artifact.pk)]
kwargs = {"artifact_pk": artifact.pk}
if distro.repository:
locks.append(distro.repository)
kwargs["repository_pk"] = distro.repository.pk
async_result = enqueue_with_reservation(import_collection,
locks,
kwargs=kwargs)
return OperationPostponedResponse(async_result, request)
def create(self, request, exporter_pk):
"""
Generates a Task to export the set of repositories assigned to a specific PulpExporter.
"""
# Validate Exporter
exporter = PulpExporter.objects.get(pk=exporter_pk).cast()
ExporterSerializer.validate_path(exporter.path, check_is_dir=True)
# Validate Export
serializer = PulpExportSerializer(data=request.data,
context={"exporter": exporter})
serializer.is_valid(raise_exception=True)
# Invoke the export
export = PulpExport.objects.create(exporter=exporter,
params=request.data)
export.validated_versions = serializer.validated_data.get(
"versions", None)
export.validated_start_versions = serializer.validated_data.get(
"start_versions", None)
export.validated_chunk_size = serializer.validated_data.get(
"chunk_size", None)
task = dispatch(pulp_export, [exporter], kwargs={"the_export": export})
return OperationPostponedResponse(task, request)
def create(self, request, repository_pk):
"""
Queues a task that creates a new RepositoryVersion by adding and removing content units
"""
add_content_units = []
remove_content_units = []
repository = self.get_parent_object()
if 'base_version' in request.data:
base_version_pk = self.get_resource(request.data['base_version'], RepositoryVersion).pk
else:
base_version_pk = None
if 'add_content_units' in request.data:
for url in request.data['add_content_units']:
content = self.get_resource(url, Content)
add_content_units.append(content.pk)
if 'remove_content_units' in request.data:
for url in request.data['remove_content_units']:
content = self.get_resource(url, Content)
remove_content_units.append(content.pk)
result = enqueue_with_reservation(
tasks.repository.add_and_remove, [repository],
kwargs={
'repository_pk': repository_pk,
'base_version_pk': base_version_pk,
'add_content_units': add_content_units,
'remove_content_units': remove_content_units
}
)
return OperationPostponedResponse(result, request)
def delete(self, request, format=None):
"""
Cleans up all the Content and Artifact orphans in the system
"""
async_result = enqueue_with_reservation(orphan_cleanup, [])
return OperationPostponedResponse(async_result, request)
def delete(self, request, format=None):
"""
Cleans up all the Content and Artifact orphans in the system
"""
task = dispatch(orphan_cleanup)
return OperationPostponedResponse(task, request)
def delete(self, request, pk, *args, **kwargs):
"""
Dispatches a task with reservation for deleting a distribution.
"""
self.get_object()
async_result = enqueue_with_reservation(tasks.distribution.delete,
"/api/v3/distributions/",
args=(pk, ))
return OperationPostponedResponse(async_result, request)
def destroy(self, request, repository_pk, number):
"""
Queues a task to handle deletion of a RepositoryVersion
"""
version = self.get_object()
task = dispatch(tasks.repository.delete_version, [version.repository],
kwargs={"pk": version.pk})
return OperationPostponedResponse(task, request)
def destroy(self, request, pk):
"""
Generates a Task to delete a Repository
"""
repo = self.get_object()
async_result = enqueue_with_reservation(tasks.repository.delete,
[repo],
kwargs={'repo_id': repo.pk})
return OperationPostponedResponse(async_result, request)
def destroy(self, request, repository_pk, number):
"""
Queues a task to handle deletion of a RepositoryVersion
"""
version = self.get_object()
async_result = enqueue_with_reservation(
tasks.repository.delete_version, [version.repository],
kwargs={'pk': version.pk})
return OperationPostponedResponse(async_result, request)
def modify(self, request, pk):
"""
Queues a task that creates a new RepositoryVersion by adding and removing content units
"""
add_content_units = {}
remove_content_units = {}
repository = self.get_object()
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
if "base_version" in request.data:
base_version_pk = self.get_resource(request.data["base_version"],
RepositoryVersion).pk
else:
base_version_pk = None
if "add_content_units" in request.data:
for url in request.data["add_content_units"]:
add_content_units[NamedModelViewSet.extract_pk(url)] = url
content_units_pks = set(add_content_units.keys())
existing_content_units = Content.objects.filter(
pk__in=content_units_pks)
existing_content_units.touch()
self.verify_content_units(existing_content_units,
add_content_units)
add_content_units = list(add_content_units.keys())
if "remove_content_units" in request.data:
if "*" in request.data["remove_content_units"]:
remove_content_units = ["*"]
else:
for url in request.data["remove_content_units"]:
remove_content_units[NamedModelViewSet.extract_pk(
url)] = url
content_units_pks = set(remove_content_units.keys())
existing_content_units = Content.objects.filter(
pk__in=content_units_pks)
self.verify_content_units(existing_content_units,
remove_content_units)
remove_content_units = list(remove_content_units.keys())
task = dispatch(
tasks.repository.add_and_remove,
exclusive_resources=[repository],
kwargs={
"repository_pk": pk,
"base_version_pk": base_version_pk,
"add_content_units": add_content_units,
"remove_content_units": remove_content_units,
},
)
return OperationPostponedResponse(task, request)
def create(self, request, *args, **kwargs):
"""
Dispatches a task with reservation for creating a distribution.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
async_result = enqueue_with_reservation(tasks.distribution.create,
"/api/v3/distributions/",
kwargs={'data': request.data})
return OperationPostponedResponse(async_result, request)
def destroy(self, request, pk, **kwargs):
"""
Delete a model instance
"""
instance = self.get_object()
serializer = self.get_serializer(instance)
app_label = instance._meta.app_label
async_result = enqueue_with_reservation(
tasks.base.general_delete, [instance],
args=(pk, app_label, serializer.__class__.__name__))
return OperationPostponedResponse(async_result, request)
def delete(self, request, format=None):
"""
Cleans up all the Content and Artifact orphans in the system
"""
deprecation_logger.warning(
"The `DELETE /pulp/api/v3/orphans/` call is deprecated. Use"
"`POST /pulp/api/v3/orphans/cleanup/` instead.")
task = dispatch(orphan_cleanup)
return OperationPostponedResponse(task, request)
def post(self, request):
"""
Repair artifacts.
"""
serializer = RepairSerializer(data=request.data)
serializer.is_valid()
verify_checksums = serializer.validated_data["verify_checksums"]
async_result = enqueue_with_reservation(repair_all_artifacts, [], args=[verify_checksums])
return OperationPostponedResponse(async_result, request)
def update(self, request, pk, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
app_label = instance._meta.app_label
async_result = enqueue_with_reservation(
tasks.base.general_update, [instance],
args=(pk, app_label, serializer.__class__.__name__),
kwargs={'data': request.data, 'partial': partial}
)
return OperationPostponedResponse(async_result, request)
def post(self, request):
"""
Repair artifacts.
"""
serializer = RepairSerializer(data=request.data)
serializer.is_valid()
verify_checksums = serializer.validated_data["verify_checksums"]
task = dispatch(repair_all_artifacts, [], args=[verify_checksums])
return OperationPostponedResponse(task, request)
def create(self, request, exporter_pk):
"""
Generates a Task to export the set of repositories assigned to a specific PulpExporter.
"""
exporter = PulpExporter.objects.get(pk=exporter_pk).cast()
result = enqueue_with_reservation(
pulp_export,
[exporter],
kwargs={'pulp_exporter': exporter},
)
return OperationPostponedResponse(result, request)
def repair(self, request, repository_pk, number):
"""
Queues a task to repair currupted artifacts corresponding to a RepositoryVersion
"""
version = self.get_object()
async_result = enqueue_with_reservation(
tasks.repository.repair_version,
[version.repository],
kwargs={"repository_version_pk": version.pk},
)
return OperationPostponedResponse(async_result, request)
def purge(self, request):
"""
Purge task-records for tasks in 'final' states.
"""
serializer = PurgeSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
task = dispatch(purge,
args=[
serializer.data["finished_before"],
list(serializer.data["states"])
])
return OperationPostponedResponse(task, request)
def create(self, request, *args, **kwargs):
"""
Dispatches a task with reservation for creating an instance.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
app_label = self.queryset.model._meta.app_label
async_result = enqueue_with_reservation(
tasks.base.general_create,
self.async_reserved_resources(None),
args=(app_label, serializer.__class__.__name__),
kwargs={'data': request.data})
return OperationPostponedResponse(async_result, request)
def destroy(self, request, repository_pk, number):
"""
Queues a task to handle deletion of a RepositoryVersion
"""
version = self.get_object()
if version.number == 0:
raise serializers.ValidationError(detail=_("Cannot delete repository version 0."))
async_result = enqueue_with_reservation(
tasks.repository.delete_version, [version.repository], kwargs={"pk": version.pk}
)
return OperationPostponedResponse(async_result, request)
def destroy(self, request, pk, **kwargs):
"""
Delete a model instance
"""
instance = self.get_object()
serializer = self.get_serializer(instance)
app_label = instance._meta.app_label
task = dispatch(
tasks.base.general_delete,
exclusive_resources=self.async_reserved_resources(instance),
args=(pk, app_label, serializer.__class__.__name__),
)
return OperationPostponedResponse(task, request)
def update(self, request, pk, **kwargs):
partial = kwargs.pop("partial", False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
app_label = instance._meta.app_label
task = dispatch(
tasks.base.general_update,
exclusive_resources=self.async_reserved_resources(instance),
args=(pk, app_label, serializer.__class__.__name__),
kwargs={"data": request.data, "partial": partial},
)
return OperationPostponedResponse(task, request)
def cleanup(self, request):
"""
Triggers an asynchronous orphan cleanup operation.
"""
serializer = OrphansCleanupSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
content_pks = serializer.validated_data.get("content_hrefs", None)
task = dispatch(orphan_cleanup, [],
kwargs={"content_pks": content_pks})
return OperationPostponedResponse(task, request)
def update(self, request, pk, partial=False):
"""
Generates a Task to update a Repository
"""
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
async_result = enqueue_with_reservation(
tasks.repository.update, [instance],
args=(instance.pk, ),
kwargs={'data': request.data, 'partial': partial}
)
return OperationPostponedResponse(async_result, request)
def commit(self, request, pk):
"""
Queues a Task that creates an Artifact, and the Upload gets deleted and cannot be re-used.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
sha256 = serializer.validated_data["sha256"]
upload = self.get_object()
async_result = enqueue_with_reservation(tasks.upload.commit, [upload],
args=(upload.pk, sha256))
return OperationPostponedResponse(async_result, request)
def commit(self, request, pk):
"""
Queues a Task that creates an Artifact, and the Upload gets deleted and cannot be re-used.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
sha256 = serializer.validated_data["sha256"]
upload = self.get_object()
task = dispatch(tasks.upload.commit,
exclusive_resources=[upload],
args=(upload.pk, sha256))
return OperationPostponedResponse(task, request)
def create(self, request, importer_pk):
"""Import a Pulp export into Pulp."""
try:
importer = PulpImporter.objects.get(pk=importer_pk)
except PulpImporter.DoesNotExist:
raise Http404
serializer = PulpImportSerializer(data=request.data, context={"request": request})
serializer.is_valid(raise_exception=True)
path = serializer.validated_data.get("path")
toc = serializer.validated_data.get("toc")
task = dispatch(
pulp_import, [importer], kwargs={"importer_pk": importer.pk, "path": path, "toc": toc}
)
return OperationPostponedResponse(task, request)
def update(self, request, pk, *args, **kwargs):
"""
Dispatches a task with reservation for updating a distribution.
"""
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
async_result = enqueue_with_reservation(
tasks.distribution.update,
"/api/v3/distributions/",
args=(pk,),
kwargs={'data': request.data, 'partial': partial}
)
return OperationPostponedResponse(async_result, request)
