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)