Example #1
0
    def _upload(self, request, *args, **kwargs):
        log.info("uploading file")
        uploaded = request.FILES.get("content")
        md5_digest = request.POST.get("md5_digest", "")
        try:
            if not can_upload(self.request.user, self.release, uploaded):
                raise FileExistsError()

            distro, isnew = Distribution.objects.get_or_create(
                release=self.release,
                pyversion=get_python_version(request.POST.get("pyversion", "")),
                filetype=get_distribution_type(request.POST.get("filetype", "sdist")),
            )
            distro.content = uploaded
            distro.uploader = request.user
            distro.comment = request.POST.get("comment", "")
            distro.signature = request.POST.get("gpg_signature", "")
            distro.md5_digest = md5_digest
            distro.save()
        except FileExistsError as e:
            transaction.rollback()
            err = "That file has already been uploaded...(%s)" % uploaded.name
            log.error(err)
            return HttpResponseForbidden(err)
        except Exception as e:  # NOQA
            transaction.rollback()
            log.exception("Failure when storing upload: %s", e)
            return HttpResponseServerError("Failure when storing upload")

        transaction.commit()
        log.info("File uploaded")
        return HttpResponse("upload accepted")
Example #2
0
File: ppadd.py Project: saxix/pyppi
    def _save_package(self, path, **kwargs):
        force_ownerid = kwargs["owner"]
        fallback_ownerid = kwargs["fallback_owner"]
        visibility = kwargs["visibility"]
        if fallback_ownerid:
            try:
                fallback_owner = User.objects.get(username=fallback_ownerid)
            except User.DoesNotExist:
                print "Fallback owner does not exists"
                return

        meta = self._get_meta(path)
        try:
            # can't use get_or_create as that demands there be an owner
            package = Package.objects.get(name=meta.name)
            isnewpackage = False
        except Package.DoesNotExist:
            package = Package(name=meta.name, visibility=visibility)
            isnewpackage = True

        release = package.get_release(meta.version)
        if not isnewpackage and release and release.version == meta.version:
            print "%s-%s already added" % (meta.name, meta.version)
            return

        # algorithm as follows: If owner is given, try to grab user with that
        # username from db. If doesn't exist, bail. If no owner set look at
        # mail address from metadata and try to get that user. If it exists
        # use it. If not, bail.
        owner = None

        if force_ownerid:
            try:
                owner = User.objects.get(username=force_ownerid)
            except User.DoesNotExist:
                print "Forced owner does not exists."
                return
        else:
            try:
                owner = User.objects.get(email=meta.author_email)
            except User.DoesNotExist:
                owner = fallback_owner

        if not owner:
            print "No owner defined. Use --owner to force one"
            return

        # at this point we have metadata and an owner, can safely add it.
        package.save()

        package.owners.add(owner)
        package.maintainers.add(owner)

        for classifier in meta.classifiers:
            package.classifiers.add(Classifier.objects.get_or_create(name=classifier)[0])

        release = Release()
        release.version = meta.version
        release.package = package
        release.metadata_version = meta.metadata_version
        package_info = MultiValueDict()
        package_info.update(meta.__dict__)
        release.package_info = package_info
        release.save()
        try:
            file = File(open(path, "rb"))
            if isinstance(meta, pkginfo.SDist):
                dist = "sdist"
            elif meta.filename.endswith(".rmp") or meta.filename.endswith(".srmp"):
                dist = "bdist_rpm"
            elif meta.filename.endswith(".exe"):
                dist = "bdist_wininst"
            elif meta.filename.endswith(".egg"):
                dist = "bdist_egg"
            elif meta.filename.endswith(".dmg"):
                dist = "bdist_dmg"
            else:
                dist = "bdist_dumb"
            release.distributions.create(content=file, uploader=owner, filetype=get_distribution_type(dist))

            print "%s-%s added" % (meta.name, meta.version)
        except FileExistsError as e:
            print e
            transaction.rollback()