def post(self, request):
"""Upload an RPM package."""
serializer = OneShotUploadSerializer(
data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
artifact = Artifact.init_and_validate(request.data['file'])
if 'repository' in request.data:
repository = serializer.validated_data['repository']
else:
repository = None
try:
artifact.save()
except IntegrityError:
# if artifact already exists, let's use it
artifact = Artifact.objects.get(sha256=artifact.sha256)
async_result = enqueue_with_reservation(
one_shot_upload, [artifact],
kwargs={
'artifact': artifact,
'repository': repository,
})
return OperationPostponedResponse(async_result, request)
def publish(self, request, pk):
"""
Dispatches a publish task.
"""
publisher = self.get_object()
serializer = RepositoryPublishURLSerializer(
data=request.data,
context={'request': request}
)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get('repository_version')
# Safe because version OR repository is enforced by serializer.
if not repository_version:
repository = serializer.validated_data.get('repository')
repository_version = RepositoryVersion.latest(repository)
result = enqueue_with_reservation(
tasks.publish,
[repository_version.repository, publisher],
kwargs={
'publisher_pk': publisher.pk,
'repository_version_pk': repository_version.pk
}
)
return OperationPostponedResponse(result, request)
def publish(self, request, pk):
"""
Publishes a repository.
Either the ``repository`` or the ``repository_version`` fields can
be provided but not both at the same time.
"""
publisher = self.get_object()
serializer = RepositoryPublishURLSerializer(
data=request.data,
context={'request': request},
)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get(
'repository_version')
result = enqueue_with_reservation(
tasks.publish_verbatim,
[repository_version.repository, publisher],
kwargs={
'publisher_pk': str(publisher.pk),
'repository_version_pk': str(repository_version.pk)
}
)
return core.OperationPostponedResponse(result, request)
def sync(self, request, pk):
"""
<!-- User-facing documentation, rendered as html-->
Trigger an asynchronous task to sync python content. The sync task will retrieve Python
content from the specified `Remote` and " update the specified `Respository`, creating a
new `RepositoryVersion`.
"""
remote = self.get_object()
serializer = RepositorySyncURLSerializer(
data=request.data,
context={'request': request}
)
serializer.is_valid(raise_exception=True)
repository = serializer.validated_data.get('repository')
mirror = serializer.validated_data.get('mirror')
result = enqueue_with_reservation(
tasks.sync,
[repository, remote],
kwargs={
'remote_pk': remote.pk,
'repository_pk': repository.pk,
'mirror': mirror
}
)
return platform.OperationPostponedResponse(result, request)
def create(self, request):
"""
Dispatches a publish task.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get('repository_version')
result = enqueue_with_reservation(
tasks.publish,
[repository_version.repository],
kwargs={
'repository_version_pk': repository_version.pk
}
)
return OperationPostponedResponse(result, request)
def run(self, request, pk):
"""Run the migration plan."""
migration_plan = self.get_object()
serializer = MigrationPlanRunSerializer(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
validate = serializer.validated_data.get('validate', False)
dry_run = serializer.validated_data.get('dry_run', False)
result = enqueue_with_reservation(migrate_from_pulp2,
[PULP_2TO3_MIGRATION_RESOURCE],
kwargs={
'migration_plan_pk':
migration_plan.pk,
'validate': validate,
'dry_run': dry_run
})
return OperationPostponedResponse(result, request)
def create(self, request):
"""Copy content."""
serializer = CopySerializer(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
dependency_solving = serializer.validated_data['dependency_solving']
config = serializer.validated_data['config']
config, repos = self._process_config(config)
async_result = enqueue_with_reservation(
tasks.copy_content,
repos,
args=[config, dependency_solving],
kwargs={})
return OperationPostponedResponse(async_result, request)
def create(self, request):
"""
Create a task which is responsible for creating a new tag.
"""
serializer = serializers.UnTagImageSerializer(
data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
tag = serializer.validated_data['tag']
repository = serializer.validated_data['repository']
result = enqueue_with_reservation(tasks.untag_image, [repository],
kwargs={
'tag': tag,
'repository_pk': repository.pk
})
return OperationPostponedResponse(result, request)
def sync(self, request, pk):
"""
Dispatches a sync task.
"""
remote = self.get_object()
serializer = RepositorySyncURLSerializer(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
repository = serializer.validated_data.get('repository')
result = enqueue_with_reservation(tasks.synchronize,
[repository, remote],
kwargs={
'remote_pk': remote.pk,
'repository_pk': repository.pk
})
return OperationPostponedResponse(result, request)
def destroy(self, request, pk, **kwargs):
"""
Delete a push repository with its distribution
"""
repository = self.get_object()
distribution = models.ContainerDistribution.objects.get(repository_id=repository.pk)
async_result = enqueue_with_reservation(
tasks.general_multi_delete,
[distribution, repository],
args=(
[
(distribution.pk, "container", "ContainerDistributionSerializer"),
(distribution.repository.pk, "container", "ContainerPushRepositorySerializer"),
],
),
)
return OperationPostponedResponse(async_result, request)
def update(self, request, pk, **kwargs):
"""Update remote."""
partial = kwargs.pop("partial", False)
lock = [self.get_object()]
repos = AnsibleRepository.objects.filter(
remote_id=pk, last_synced_metadata_time__isnull=False).all()
lock.extend(repos)
async_result = enqueue_with_reservation(
update_collection_remote,
lock,
args=(pk, ),
kwargs={
"data": request.data,
"partial": partial
},
)
return OperationPostponedResponse(async_result, request)
def sync(self, request, pk):
"""
Synchronizes a repository. The ``repository`` field has to be provided.
"""
remote = self.get_object()
serializer = RepositorySyncURLSerializer(data=request.data,
context={'request': request})
# Validate synchronously to return 400 errors.
serializer.is_valid(raise_exception=True)
repository = serializer.validated_data.get('repository')
result = enqueue_with_reservation(tasks.synchronize,
[repository, remote],
kwargs={
'remote_pk': remote.pk,
'repository_pk': repository.pk
})
return OperationPostponedResponse(result, request)
def create(self, request):
"""
Dispatches a publish task.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get(
'repository_version')
repository = RpmRepository.objects.get(
pk=repository_version.repository.pk)
result = enqueue_with_reservation(
tasks.publish, [repository_version.repository],
kwargs={
'repository_version_pk': repository_version.pk,
'metadata_signing_service': repository.metadata_signing_service
})
return OperationPostponedResponse(result, request)
def create(self, request):
"""
Publishes a repository.
Either the ``repository`` or the ``repository_version`` fields can
be provided but not both at the same time.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get(
"repository_version")
result = enqueue_with_reservation(
tasks.publish_verbatim,
[repository_version.repository],
kwargs={"repository_version_pk": str(repository_version.pk)},
)
return OperationPostponedResponse(result, request)
def untag(self, request, pk):
"""
Create a task which is responsible for untagging an image.
"""
repository = self.get_object()
request.data["repository"] = repository
serializer = serializers.UnTagImageSerializer(
data=request.data, context={"request": request}
)
serializer.is_valid(raise_exception=True)
tag = serializer.validated_data["tag"]
result = enqueue_with_reservation(
tasks.untag_image, [repository], kwargs={"tag": tag, "repository_pk": repository.pk}
)
return OperationPostponedResponse(result, request)
def sync(self, request, pk):
"""
Dispatches a sync task.
"""
repository = self.get_object()
serializer = RepositorySyncURLSerializer(data=request.data, context={"request": request})
# Validate synchronously to return 400 errors.
serializer.is_valid(raise_exception=True)
remote = serializer.validated_data.get("remote")
mirror = serializer.validated_data.get("mirror", True)
result = enqueue_with_reservation(
tasks.synchronize,
[repository, remote],
kwargs={"remote_pk": remote.pk, "repository_pk": repository.pk, "mirror": mirror},
)
return OperationPostponedResponse(result, request)
def publish(self, request, pk):
"""
Publishes a repository. Either the ``repository`` or the ``repository_version`` fields can
be provided but not both at the same time.
"""
publisher = self.get_object()
serializer = RepositoryPublishURLSerializer(
data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get(
'repository_version')
result = enqueue_with_reservation(
tasks.publish, [repository_version.repository, publisher],
kwargs={
'publisher_pk': str(publisher.pk),
'repository_version_pk': str(repository_version.pk)
})
return OperationPostponedResponse(result, request)
def create(self, request):
"""
<!-- User-facing documentation, rendered as html-->
Dispatches a publish task, which generates metadata that will be used by pip.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get(
'repository_version')
# Safe because version OR repository is enforced by serializer.
if not repository_version:
repository = serializer.validated_data.get('repository')
repository_version = RepositoryVersion.latest(repository)
result = enqueue_with_reservation(
tasks.publish, [repository_version.repository],
kwargs={'repository_version_pk': repository_version.pk})
return core_viewsets.OperationPostponedResponse(result, request)
def create(self, request):
"""
Queues a task that publishes a new Ansible Publication.
"""
serializer = RepositoryPublishURLSerializer(
data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get(
'repository_version')
# Safe because version OR repository is enforced by serializer.
if not repository_version:
repository = serializer.validated_data.get('repository')
repository_version = RepositoryVersion.latest(repository)
result = enqueue_with_reservation(
tasks.publish, [repository_version.repository],
kwargs={'repository_version_pk': str(repository_version.pk)})
return OperationPostponedResponse(result, request)
def destroy(self, request, pk, **kwargs):
"""
Delete a distribution. If a push repository is associated to it, delete it as well.
"""
distribution = self.get_object()
reservations = [distribution]
instance_ids = [
(distribution.pk, "container", "ContainerDistributionSerializer"),
]
if distribution.repository and distribution.repository.cast(
).PUSH_ENABLED:
reservations.append(distribution.repository)
instance_ids.append((distribution.repository.pk, "container",
"ContainerPushRepositorySerializer"), )
async_result = enqueue_with_reservation(tasks.general_multi_delete,
reservations,
args=(instance_ids, ))
return OperationPostponedResponse(async_result, request)
def sync(self, request, pk):
"""
Synchronizes a repository.
The ``repository`` field has to be provided.
"""
serializer = RepositorySyncURLSerializer(data=request.data, context={"request": request})
serializer.is_valid(raise_exception=True)
repository = self.get_object()
remote = serializer.validated_data.get("remote")
mirror = serializer.validated_data.get("mirror", False)
result = enqueue_with_reservation(
tasks.synchronize,
[repository, remote],
kwargs={"remote_pk": remote.pk, "repository_pk": repository.pk, "mirror": mirror},
)
return OperationPostponedResponse(result, request)
def sync(self, request, pk):
"""
Synchronizes a repository. The ``repository`` field has to be provided.
"""
remote = self.get_object()
serializer = RepositorySyncURLSerializer(data=request.data, context={'request': request})
# Validate synchronously to return 400 errors.
serializer.is_valid(raise_exception=True)
repository = serializer.validated_data.get('repository')
result = enqueue_with_reservation(
tasks.synchronize,
[repository, remote],
kwargs={
'remote_pk': remote.pk,
'repository_pk': repository.pk
}
)
return OperationPostponedResponse(result, request)
def sync(self, request, pk):
"""
Dispatches a Collection sync task.
"""
collection_remote = self.get_object()
serializer = RepositorySyncURLSerializer(data=request.data, context={"request": request})
serializer.is_valid(raise_exception=True)
repository = serializer.validated_data.get("repository")
mirror = serializer.validated_data.get("mirror", False)
kwargs = {
"remote_pk": collection_remote.pk,
"repository_pk": repository.pk,
"mirror": mirror,
}
result = enqueue_with_reservation(
collection_sync, [repository, collection_remote], kwargs=kwargs
)
return OperationPostponedResponse(result, request)
def tag(self, request, pk):
"""
Create a task which is responsible for creating a new tag.
"""
repository = self.get_object()
request.data["repository"] = repository
serializer = serializers.TagImageSerializer(data=request.data, context={"request": request})
serializer.is_valid(raise_exception=True)
manifest = serializer.validated_data["manifest"]
tag = serializer.validated_data["tag"]
result = enqueue_with_reservation(
tasks.tag_image,
[repository, manifest],
kwargs={"manifest_pk": manifest.pk, "tag": tag, "repository_pk": repository.pk},
)
return OperationPostponedResponse(result, request)
def post(self, request: Request, *args, **kwargs) -> Response:
distro_path = kwargs['path']
distro = get_object_or_404(pulp_models.AnsibleDistribution,
base_path=distro_path)
if not distro.repository or not distro.repository.remote:
raise ValidationError(
detail={
'remote':
f'The {distro_path} distribution does not have'
' any remotes associated with it.'
})
remote = distro.repository.remote.ansible_collectionremote
if not remote.requirements_file and any(
[domain in remote.url for domain in COMMUNITY_DOMAINS]):
raise ValidationError(
detail={
'requirements_file':
'Syncing content from galaxy.ansible.com without specifying a '
'requirements file is not allowed.'
})
result = enqueue_with_reservation(
collection_sync,
[distro.repository, remote],
kwargs={
"remote_pk": remote.pk,
"repository_pk": distro.repository.pk,
"mirror": True,
"optimize": True,
},
)
repo = pulp_models.AnsibleRepository.objects.get(
pk=distro.repository.pk)
task = Task.objects.get(pk=result.id)
models.CollectionSyncTask.objects.create(repository=repo, task=task)
return Response({'task': task.pk})
def add(self, request, pk):
"""
Queues a task that creates a new RepositoryVersion by adding content units.
"""
add_content_units = []
repository = self.get_object()
serializer = serializers.RecursiveManageSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
if "content_units" in request.data:
for url in request.data["content_units"]:
content = NamedModelViewSet.get_resource(url, Content)
add_content_units.append(content.pk)
result = enqueue_with_reservation(
tasks.recursive_add_content,
[repository],
kwargs={"repository_pk": repository.pk, "content_units": add_content_units},
)
return OperationPostponedResponse(result, request)
def create(self, request):
"""
Create a task which is responsible for initializing a new repository version.
"""
serializer = serializers.TagImageSerializer(
data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
manifest = serializer.validated_data['manifest']
tag = serializer.validated_data['tag']
repository = serializer.validated_data['repository']
result = enqueue_with_reservation(tasks.tag_image,
[repository, manifest],
kwargs={
'manifest_pk': manifest.pk,
'tag': tag,
'repository_pk': repository.pk
})
return OperationPostponedResponse(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)
result = enqueue_with_reservation(pulp_export, [exporter], kwargs={"the_export": export})
return OperationPostponedResponse(result, request)
def sync(self, request, pk):
"""
<!-- User-facing documentation, rendered as html-->
Trigger an asynchronous task to sync python content. The sync task will retrieve Python
content from the specified `Remote` and " update the specified `Respository`, creating a
new `RepositoryVersion`.
"""
repository = self.get_object()
serializer = RepositorySyncURLSerializer(data=request.data,
context={'request': request})
serializer.is_valid(raise_exception=True)
remote = serializer.validated_data.get('remote')
mirror = serializer.validated_data.get('mirror')
result = enqueue_with_reservation(tasks.sync, [repository, remote],
kwargs={
'remote_pk': remote.pk,
'repository_pk': repository.pk,
'mirror': mirror
})
return core_viewsets.OperationPostponedResponse(result, request)
def synchronize(self, request, pk):
"""
Dispatches a sync task.
"""
remote = self.get_object()
serializer = RepositorySyncURLSerializer(
data=request.data,
context={'request': request}
)
serializer.is_valid(raise_exception=True)
repository = serializer.validated_data.get('repository')
result = enqueue_with_reservation(
tasks.synchronize,
[repository, remote],
kwargs={
'remote_pk': remote.pk,
'repository_pk': repository.pk
}
)
return OperationPostponedResponse(result, request)
def publish(self, request, pk):
"""
Dispatches a publish task.
"""
publisher = self.get_object()
serializer = RepositoryPublishURLSerializer(
data=request.data, context={'request': request})
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get(
'repository_version')
# Safe because version OR repository is enforced by serializer.
if not repository_version:
repository = serializer.validated_data.get('repository')
repository_version = RepositoryVersion.latest(repository)
result = enqueue_with_reservation(
tasks.publish, [repository_version.repository, publisher],
kwargs={
'publisher_pk': str(publisher.pk),
'repository_version_pk': str(repository_version.pk)
})
return OperationPostponedResponse(result, request)
def create(self, request):
"""
<!-- User-facing documentation, rendered as html-->
Dispatches a publish task, which generates metadata that will be used by pip.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get('repository_version')
# Safe because version OR repository is enforced by serializer.
if not repository_version:
repository = serializer.validated_data.get('repository')
repository_version = RepositoryVersion.latest(repository)
result = enqueue_with_reservation(
tasks.publish,
[repository_version.repository],
kwargs={
'repository_version_pk': repository_version.pk
}
)
return platform.OperationPostponedResponse(result, request)
def create(self, request):
"""
Create a content unit.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
artifact = serializer.validated_data["artifact"]
repository = serializer.validated_data.get("repository")
task_payload = {k: v for k, v in request.data.items()}
if task_payload.pop("file", None):
# in the upload code path make sure, the artifact exists, and the 'file'
# parameter is replaced by 'artifact'
try:
artifact.save()
except IntegrityError:
# if artifact already exists, let's use it
artifact = Artifact.objects.get(sha256=artifact.sha256)
task_payload["artifact"] = ArtifactSerializer(artifact,
context={
"request":
request
}).data["pulp_href"]
shared_resources = [artifact]
if repository:
shared_resources.append(repository)
app_label = self.queryset.model._meta.app_label
async_result = enqueue_with_reservation(
tasks.base.general_create,
shared_resources,
args=(app_label, serializer.__class__.__name__),
kwargs={
"data": task_payload,
"context": self.get_deferred_context(request),
},
)
return OperationPostponedResponse(async_result, request)
def create(self, request):
"""
Queues a task that creates a new RepositoryVersion by adding content units.
"""
add_content_units = []
serializer = serializers.RecursiveManageSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
repository = serializer.validated_data['repository']
if 'content_units' in request.data:
for url in request.data['content_units']:
content = NamedModelViewSet.get_resource(url, Content)
add_content_units.append(content.pk)
result = enqueue_with_reservation(tasks.recursive_add_content,
[repository],
kwargs={
'repository_pk': repository.pk,
'content_units':
add_content_units,
})
return OperationPostponedResponse(result, request)
def create(self, request):
"""Create a content unit."""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
content_data = self.init_content_data(serializer, request)
repository = serializer.validated_data.get("repository")
if repository:
content_data.shared_resources.append(repository)
app_label = self.queryset.model._meta.app_label
async_result = enqueue_with_reservation(
tasks.base.general_create,
content_data.shared_resources,
args=(app_label, serializer.__class__.__name__),
kwargs={
"data": content_data.task_payload,
"context": self.get_deferred_context(request),
},
)
return OperationPostponedResponse(async_result, request)
def create(self, request):
"""
Dispatches a publish task.
"""
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
repository_version = serializer.validated_data.get("repository_version")
repository = RpmRepository.objects.get(pk=repository_version.repository.pk)
metadata_checksum_type = serializer.validated_data.get(
"metadata_checksum_type", repository.metadata_checksum_type
)
package_checksum_type = serializer.validated_data.get(
"package_checksum_type", repository.package_checksum_type
)
checksum_types = dict(
metadata=metadata_checksum_type,
package=package_checksum_type,
)
gpgcheck_options = dict(
gpgcheck=serializer.validated_data.get("gpgcheck", repository.gpgcheck),
repo_gpgcheck=serializer.validated_data.get("repo_gpgcheck", repository.repo_gpgcheck),
)
sqlite_metadata = serializer.validated_data.get(
"sqlite_metadata", repository.sqlite_metadata
)
result = enqueue_with_reservation(
tasks.publish,
[repository_version.repository],
kwargs={
"repository_version_pk": repository_version.pk,
"metadata_signing_service": repository.metadata_signing_service,
"checksum_types": checksum_types,
"gpgcheck_options": gpgcheck_options,
"sqlite_metadata": sqlite_metadata,
},
)
return OperationPostponedResponse(result, request)
def create(self, request):
"""
Queues a task that creates a new RepositoryVersion by adding content units.
"""
names = request.data.get("names")
serializer = serializers.TagCopySerializer(data=request.data)
serializer.is_valid(raise_exception=True)
source_latest = serializer.validated_data['source_repository_version']
destination = serializer.validated_data['destination_repository']
content_tags_in_repo = source_latest.content.filter(_type="docker.tag")
tags_in_repo = models.Tag.objects.filter(pk__in=content_tags_in_repo, )
if names is None:
tags_to_add = tags_in_repo
else:
tags_to_add = tags_in_repo.filter(name__in=names)
result = enqueue_with_reservation(
tasks.recursive_add_content, [destination],
kwargs={
'repository_pk': destination.pk,
'content_units': tags_to_add.values_list('pk', flat=True),
})
return OperationPostponedResponse(result, request)
def remove_image(self, request, pk):
"""
Create a task which deletes an image by the passed digest.
"""
repository = self.get_object()
request.data["repository"] = repository
serializer = serializers.RemoveImageSerializer(
data=request.data, context={"request": request})
serializer.is_valid(raise_exception=True)
content_units_to_remove = list(serializer.validated_data["tags_pks"])
content_units_to_remove.append(
serializer.validated_data["manifest"].pk)
result = enqueue_with_reservation(
tasks.recursive_remove_content,
[repository],
kwargs={
"repository_pk": repository.pk,
"content_units": content_units_to_remove
},
)
return OperationPostponedResponse(result, request)
