Exemple #1
0
    def initUpload(self, parentType, parentId, name, size, mimeType, linkUrl, reference,
                   assetstoreId):
        """
        Before any bytes of the actual file are sent, a request should be made
        to initialize the upload. This creates the temporary record of the
        forthcoming upload that will be passed in chunks to the readChunk
        method. If you pass a "linkUrl" parameter, it will make a link file
        in the designated parent.
        """
        user = self.getCurrentUser()
        parent = self.model(parentType).load(
            id=parentId, user=user, level=AccessType.WRITE, exc=True)

        if linkUrl is not None:
            return self.model('file').filter(
                self.model('file').createLinkFile(
                    url=linkUrl, parent=parent, name=name, parentType=parentType, creator=user,
                    size=size, mimeType=mimeType), user)
        else:
            self.requireParams({'size': size})
            assetstore = None
            if assetstoreId:
                self.requireAdmin(
                    user, message='You must be an admin to select a destination assetstore.')
                assetstore = self.model('assetstore').load(assetstoreId)

            chunk = None
            if size > 0 and cherrypy.request.headers.get('Content-Length'):
                ct = cherrypy.request.body.content_type.value
                if (ct not in cherrypy.request.body.processors and
                        ct.split('/', 1)[0] not in cherrypy.request.body.processors):
                    chunk = RequestBodyStream(cherrypy.request.body)
            if chunk is not None and chunk.getSize() <= 0:
                chunk = None

            try:
                # TODO: This can be made more efficient by adding
                #    save=chunk is None
                # to the createUpload call parameters.  However, since this is
                # a breaking change, that should be deferred until a major
                # version upgrade.
                upload = self.model('upload').createUpload(
                    user=user, name=name, parentType=parentType, parent=parent, size=size,
                    mimeType=mimeType, reference=reference, assetstore=assetstore)
            except OSError as exc:
                if exc.errno == errno.EACCES:
                    raise GirderException(
                        'Failed to create upload.', 'girder.api.v1.file.create-upload-failed')
                raise
            if upload['size'] > 0:
                if chunk:
                    return self.model('upload').handleChunk(upload, chunk, filter=True, user=user)

                return upload
            else:
                return self.model('file').filter(
                    self.model('upload').finalizeUpload(upload), user)
Exemple #2
0
    def create_file(self, event, path, root, user=None):
        params = event.info["params"]
        self.is_dir(path, root["_id"])

        name = params["name"]
        parent = Folder().filter(self.vFolder(path, root), user=user)
        file_path = path / name
        try:
            with file_path.open(mode="a"):
                os.utime(file_path.as_posix())
        except PermissionError:
            raise GirderException(
                "Insufficient perms to write on {}".format(path.as_posix()),
                "girder.api.v1.file.create-upload-failed",
            )
        except Exception:
            raise

        size = int(params["size"])
        chunk = None
        if size > 0 and cherrypy.request.headers.get("Content-Length"):
            ct = cherrypy.request.body.content_type.value
            if (
                ct not in cherrypy.request.body.processors
                and ct.split("/", 1)[0] not in cherrypy.request.body.processors
            ):
                chunk = RequestBodyStream(cherrypy.request.body)
        if chunk is not None and chunk.getSize() <= 0:
            chunk = None
        upload = Upload().createUpload(
            user=user, name=name, parentType="folder", parent=parent, size=size
        )

        if upload["size"] > 0:
            if chunk:
                fobj = self._handle_chunk(upload, chunk, filter=True, user=user)
                event.preventDefault().addResponse(fobj)
                return
            event.preventDefault().addResponse(upload)
        else:
            event.preventDefault().addResponse(
                File().filter(self.vFile(file_path, root), user=user)
            )