libervia-backend: sat/plugins/plugin_comp_file_sharing

comparison sat/plugins/plugin_comp_file_sharing_management.py @ 3541:888109774673

core: various changes and fixes to work with new storage and D-Bus bridge: - fixes coroutines handling in various places - fixes types which are not serialised by Tx DBus - XEP-0384: call storage methods in main thread in XEP: Python OMEMO's Promise use thread which prevent the use of AsyncIO loop. To work around that, callLater is used to launch storage method in main thread. This is a temporary workaround, as Python OMEMO should get rid of Promise implementation and threads soon.

author	Goffi <goffi@goffi.org>
date	Thu, 03 Jun 2021 15:21:43 +0200
parents	a8259a1f89b2
children	7af29260ecb8

comparison

equal deleted inserted replaced

-:aa58451b77ba
+:888109774673
 form.addField(field)
 payload = form.toElement()
 return payload, status, None, None
-@defer.inlineCallbacks
+async def _getFileData(self, client, session_data, command_form):
-def _getFileData(self, client, session_data, command_form):
 """Retrieve field requested in root form
 "found_file" will also be set in session_data
 @param command_form(data_form.Form): response to root form
 @return (D(dict)): found file data
 # TODO: if parent_path and basename are empty, we ask for root directory
 #       this must be managed
 try:
-found_files = yield self.host.memory.getFiles(
+found_files = await self.host.memory.getFiles(
 client, requestor_bare, path=parent_path, name=basename,
 namespace=namespace)
 found_file = found_files[0]
 except (exceptions.NotFound, IndexError):
 raise WorkflowError(self._err(_("file not found")))
 log.warning(_("Only owner can manage files"))
 raise WorkflowError(self._err(_("forbidden")))
 session_data['found_file'] = found_file
 session_data['namespace'] = namespace
-defer.returnValue(found_file)
+return found_file
 def _updateReadPermission(self, access, allowed_jids):
 if not allowed_jids:
 if C.ACCESS_PERM_READ in access:
 del access[C.ACCESS_PERM_READ]
 access[C.ACCESS_PERM_READ] = {
 "type": C.ACCESS_TYPE_WHITELIST,
 "jids": [j.full() for j in allowed_jids]
 }
-@defer.inlineCallbacks
+async def _updateDir(self, client, requestor, namespace, file_data, allowed_jids):
-def _updateDir(self, client, requestor, namespace, file_data, allowed_jids):
 """Recursively update permission of a directory and all subdirectories
 @param file_data(dict): metadata of the file
 @param allowed_jids(list[jid.JID]): list of entities allowed to read the file
 """
 assert file_data['type'] == C.FILE_TYPE_DIRECTORY
-files_data = yield self.host.memory.getFiles(
+files_data = await self.host.memory.getFiles(
 client, requestor, parent=file_data['id'], namespace=namespace)
 for file_data in files_data:
 if not file_data['access'].get(C.ACCESS_PERM_READ, {}):
 log.debug("setting {perm} read permission for {name}".format(
 perm=allowed_jids, name=file_data['name']))
-yield self.host.memory.fileUpdate(
+await self.host.memory.fileUpdate(
 file_data['id'], 'access',
 partial(self._updateReadPermission, allowed_jids=allowed_jids))
 if file_data['type'] == C.FILE_TYPE_DIRECTORY:
-yield self._updateDir(client, requestor, namespace, file_data, 'PUBLIC')
+await self._updateDir(client, requestor, namespace, file_data, 'PUBLIC')
-@defer.inlineCallbacks
+async def _onChangeFile(self, client, command_elt, session_data, action, node):
-def _onChangeFile(self, client, command_elt, session_data, action, node):
 try:
 x_elt = next(command_elt.elements(data_form.NS_X_DATA, "x"))
 command_form = data_form.Form.fromElement(x_elt)
 except StopIteration:
 command_form = None
 requestor = session_data['requestor']
 requestor_bare = requestor.userhostJID()
 if command_form is None or len(command_form.fields) == 0:
 # root request
-defer.returnValue(self._getRootArgs())
+return self._getRootArgs()
 elif found_file is None:
 # file selected, we retrieve it and ask for permissions
 try:
-found_file = yield self._getFileData(client, session_data, command_form)
+found_file = await self._getFileData(client, session_data, command_form)
 except WorkflowError as e:
-defer.returnValue(e.err_args)
+return e.err_args
 # management request
 if found_file['type'] == C.FILE_TYPE_DIRECTORY:
 instructions = D_("Please select permissions for this directory")
 else:
 )
 form.addField(field)
 status = self._c.STATUS.EXECUTING
 payload = form.toElement()
-defer.returnValue((payload, status, None, None))
+return (payload, status, None, None)
 else:
 # final phase, we'll do permission change here
 try:
 read_allowed = command_form.fields['read_allowed']
 log.warning(_("Can't use read_allowed values: {reason}").format(
 reason=e))
 self._c.adHocError(self._c.ERROR.BAD_PAYLOAD)
 if found_file['type'] == C.FILE_TYPE_FILE:
-yield self.host.memory.fileUpdate(
+await self.host.memory.fileUpdate(
 found_file['id'], 'access',
 partial(self._updateReadPermission, allowed_jids=allowed_jids))
 else:
 try:
 recursive = command_form.fields['recursive']
 except KeyError:
 self._c.adHocError(self._c.ERROR.BAD_PAYLOAD)
-yield self.host.memory.fileUpdate(
+await self.host.memory.fileUpdate(
 found_file['id'], 'access',
 partial(self._updateReadPermission, allowed_jids=allowed_jids))
 if recursive:
 # we set all file under the directory as public (if they haven't
 # already a permission set), so allowed entities of root directory
 # can read them.
 namespace = session_data['namespace']
-yield self._updateDir(
+await self._updateDir(
 client, requestor_bare, namespace, found_file, 'PUBLIC')
 # job done, we can end the session
 status = self._c.STATUS.COMPLETED
 payload = None
 note = (self._c.NOTE.INFO, _("management session done"))
-defer.returnValue((payload, status, None, note))
+return (payload, status, None, note)
-@defer.inlineCallbacks
+async def _onDeleteFile(self, client, command_elt, session_data, action, node):
-def _onDeleteFile(self, client, command_elt, session_data, action, node):
 try:
 x_elt = next(command_elt.elements(data_form.NS_X_DATA, "x"))
 command_form = data_form.Form.fromElement(x_elt)
 except StopIteration:
 command_form = None
 requestor = session_data['requestor']
 requestor_bare = requestor.userhostJID()
 if command_form is None or len(command_form.fields) == 0:
 # root request
-defer.returnValue(self._getRootArgs())
+return self._getRootArgs()
 elif found_file is None:
 # file selected, we need confirmation before actually deleting
 try:
-found_file = yield self._getFileData(client, session_data, command_form)
+found_file = await self._getFileData(client, session_data, command_form)
 except WorkflowError as e:
-defer.returnValue(e.err_args)
+return e.err_args
 if found_file['type'] == C.FILE_TYPE_DIRECTORY:
 msg = D_("Are you sure to delete directory {name} and all files and "
 "directories under it?").format(name=found_file['name'])
 else:
 msg = D_("Are you sure to delete file {name}?"
 desc="check this box to confirm"
 )
 form.addField(field)
 status = self._c.STATUS.EXECUTING
 payload = form.toElement()
-defer.returnValue((payload, status, None, None))
+return (payload, status, None, None)
 else:
 # final phase, we'll do deletion here
 try:
 confirmed = C.bool(command_form.fields['confirm'].value)
 self._c.adHocError(self._c.ERROR.BAD_PAYLOAD)
 if not confirmed:
 note = None
 else:
 recursive = found_file['type'] == C.FILE_TYPE_DIRECTORY
-yield self.host.memory.fileDelete(
+await self.host.memory.fileDelete(
 client, requestor_bare, found_file['id'], recursive)
 note = (self._c.NOTE.INFO, _("file deleted"))
 status = self._c.STATUS.COMPLETED
 payload = None
-defer.returnValue((payload, status, None, note))
+return (payload, status, None, note)
 def _updateThumbs(self, extra, thumbnails):
 extra[C.KEY_THUMBNAILS] = thumbnails
-@defer.inlineCallbacks
+async def _genThumbs(self, client, requestor, namespace, file_data):
-def _genThumbs(self, client, requestor, namespace, file_data):
 """Recursively generate thumbnails
 @param file_data(dict): metadata of the file
 """
 if file_data['type'] == C.FILE_TYPE_DIRECTORY:
-sub_files_data = yield self.host.memory.getFiles(
+sub_files_data = await self.host.memory.getFiles(
 client, requestor, parent=file_data['id'], namespace=namespace)
 for sub_file_data in sub_files_data:
-yield self._genThumbs(client, requestor, namespace, sub_file_data)
+await self._genThumbs(client, requestor, namespace, sub_file_data)
 elif file_data['type'] == C.FILE_TYPE_FILE:
 media_type = file_data['media_type']
 file_path = os.path.join(self.files_path, file_data['file_hash'])
 if media_type == 'image':
 thumbnails = []
 for max_thumb_size in self._t.SIZES:
 try:
-thumb_size, thumb_id = yield self._t.generateThumbnail(
+thumb_size, thumb_id = await self._t.generateThumbnail(
 file_path,
 max_thumb_size,
 #  we keep thumbnails for 6 months
 60 * 60 * 24 * 31 * 6,
 )
 log.warning(_("Can't create thumbnail: {reason}")
 .format(reason=e))
 break
 thumbnails.append({"id": thumb_id, "size": thumb_size})
-yield self.host.memory.fileUpdate(
+await self.host.memory.fileUpdate(
 file_data['id'], 'extra',
 partial(self._updateThumbs, thumbnails=thumbnails))
 log.info("thumbnails for [{file_name}] generated"
 .format(file_name=file_data['name']))
 else:
 log.warning("unmanaged file type: {type_}".format(type_=file_data['type']))
-@defer.inlineCallbacks
+async def _onGenThumbnails(self, client, command_elt, session_data, action, node):
-def _onGenThumbnails(self, client, command_elt, session_data, action, node):
 try:
 x_elt = next(command_elt.elements(data_form.NS_X_DATA, "x"))
 command_form = data_form.Form.fromElement(x_elt)
 except StopIteration:
 command_form = None
 found_file = session_data.get('found_file')
 requestor = session_data['requestor']
 if command_form is None or len(command_form.fields) == 0:
 # root request
-defer.returnValue(self._getRootArgs())
+return self._getRootArgs()
 elif found_file is None:
 # file selected, we retrieve it and ask for permissions
 try:
-found_file = yield self._getFileData(client, session_data, command_form)
+found_file = await self._getFileData(client, session_data, command_form)
 except WorkflowError as e:
-defer.returnValue(e.err_args)
+return e.err_args
 log.info("Generating thumbnails as requested")
-yield self._genThumbs(client, requestor, found_file['namespace'], found_file)
+await self._genThumbs(client, requestor, found_file['namespace'], found_file)
 # job done, we can end the session
 status = self._c.STATUS.COMPLETED
 payload = None
 note = (self._c.NOTE.INFO, _("thumbnails generated"))
-defer.returnValue((payload, status, None, note))
+return (payload, status, None, note)
 async def _onQuota(self, client, command_elt, session_data, action, node):
 requestor = session_data['requestor']
 quota = self.host.plugins["file_sharing"].getQuota(client, requestor)
 try:

Mercurial > libervia-backend

comparison sat/plugins/plugin_comp_file_sharing_management.py @ 3541:888109774673