libervia-backend: sat/memory/memory.py comparison

comparison sat/memory/memory.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	f9a5b810f14d
children	71516731d0aa

comparison

equal deleted inserted replaced

-:aa58451b77ba
+:888109774673
 return self.params._getParamsValuesFromCategory(
 category, security_limit, app, extra_s, profile_key
 )
 def asyncGetStringParamA(
-self, name, category, attr="value", security_limit=C.NO_SECURITY_LIMIT,
+self, name, category, attribute="value", security_limit=C.NO_SECURITY_LIMIT,
 profile_key=C.PROF_KEY_NONE):
 profile = self.getProfileName(profile_key)
 return defer.ensureDeferred(self.params.asyncGetStringParamA(
-name, category, attr, security_limit, profile
+name, category, attribute, security_limit, profile
 ))
 def _getParamsUI(self, security_limit, app, extra_s, profile_key):
 return self.params._getParamsUI(security_limit, app, extra_s, profile_key)
 def _privateDataSet(self, namespace, key, data_s, profile_key):
 client = self.host.getClient(profile_key)
 # we accept any type
 data = data_format.deserialise(data_s, type_check=None)
-return self.storage.setPrivateValue(
+return defer.ensureDeferred(self.storage.setPrivateValue(
-namespace, key, data, binary=True, profile=client.profile)
+namespace, key, data, binary=True, profile=client.profile))
 def _privateDataGet(self, namespace, key, profile_key):
 client = self.host.getClient(profile_key)
-d = self.storage.getPrivates(
+d = defer.ensureDeferred(
-namespace, [key], binary=True, profile=client.profile)
+self.storage.getPrivates(
+namespace, [key], binary=True, profile=client.profile)
+)
 d.addCallback(lambda data_dict: data_format.serialise(data_dict.get(key)))
 return d
 def _privateDataDelete(self, namespace, key, profile_key):
 client = self.host.getClient(profile_key)
-return self.storage.delPrivateValue(
+return defer.ensureDeferred(self.storage.delPrivateValue(
-namespace, key, binary=True, profile=client.profile)
+namespace, key, binary=True, profile=client.profile))
 ## Files ##
 def checkFilePermission(
 self,
 else:
 raise exceptions.InternalError(
 _("unknown access type: {type}").format(type=perm_type)
 )
-@defer.inlineCallbacks
+async def checkPermissionToRoot(self, client, file_data, peer_jid, perms_to_check):
-def checkPermissionToRoot(self, client, file_data, peer_jid, perms_to_check):
 """do checkFilePermission on file_data and all its parents until root"""
 current = file_data
 while True:
 self.checkFilePermission(current, peer_jid, perms_to_check)
 parent = current["parent"]
 if not parent:
 break
-files_data = yield self.getFiles(
+files_data = await self.getFiles(
 client, peer_jid=None, file_id=parent, perms_to_check=None
 )
 try:
 current = files_data[0]
 except IndexError:
 raise exceptions.DataError("Missing parent")
-@defer.inlineCallbacks
+async def _getParentDir(
-def _getParentDir(
 self, client, path, parent, namespace, owner, peer_jid, perms_to_check
 ):
 """Retrieve parent node from a path, or last existing directory
 each directory of the path will be retrieved, until the last existing one
 # we retrieve all directories from path until we get the parent container
 # non existing directories will be created
 parent = ""
 for idx, path_elt in enumerate(path_elts):
-directories = yield self.storage.getFiles(
+directories = await self.storage.getFiles(
 client,
 parent=parent,
 type_=C.FILE_TYPE_DIRECTORY,
 name=path_elt,
 namespace=namespace,
 owner=owner,
 )
 if not directories:
-defer.returnValue((parent, path_elts[idx:]))
+return (parent, path_elts[idx:])
 # from this point, directories don't exist anymore, we have to create them
 elif len(directories) > 1:
 raise exceptions.InternalError(
 _("Several directories found, this should not happen")
 )
 else:
 directory = directories[0]
 self.checkFilePermission(directory, peer_jid, perms_to_check)
 parent = directory["id"]
-defer.returnValue((parent, []))
+return (parent, [])
 def getFileAffiliations(self, file_data: dict) -> Dict[jid.JID, str]:
 """Convert file access to pubsub like affiliations"""
 affiliations = {}
 access_data = file_data['access']
 raise exceptions.InternalError(
 "Owner must be set for component if peer_jid is None"
 )
 return peer_jid.userhostJID()
-@defer.inlineCallbacks
+async def getFiles(
-def getFiles(
 self, client, peer_jid, file_id=None, version=None, parent=None, path=None,
 type_=None, file_hash=None, hash_algo=None, name=None, namespace=None,
 mime_type=None, public_id=None, owner=None, access=None, projection=None,
 unique=False, perms_to_check=(C.ACCESS_PERM_READ,)):
 """Retrieve files with with given filters
 )
 owner = self.getFilesOwner(client, owner, peer_jid, file_id, parent)
 if path is not None:
 path = str(path)
 # permission are checked by _getParentDir
-parent, remaining_path_elts = yield self._getParentDir(
+parent, remaining_path_elts = await self._getParentDir(
 client, path, parent, namespace, owner, peer_jid, perms_to_check
 )
 if remaining_path_elts:
 # if we have remaining path elements,
 # the parent directory is not found
 raise failure.Failure(exceptions.NotFound())
 if parent and peer_jid:
 # if parent is given directly and permission check is requested,
 # we need to check all the parents
-parent_data = yield self.storage.getFiles(client, file_id=parent)
+parent_data = await self.storage.getFiles(client, file_id=parent)
 try:
 parent_data = parent_data[0]
 except IndexError:
 raise exceptions.DataError("mising parent")
-yield self.checkPermissionToRoot(
+await self.checkPermissionToRoot(
 client, parent_data, peer_jid, perms_to_check
 )
-files = yield self.storage.getFiles(
+files = await self.storage.getFiles(
 client,
 file_id=file_id,
 version=version,
 parent=parent,
 type_=type_,
 if peer_jid:
 # if permission are checked, we must remove all file that user can't access
 to_remove = []
 for file_data in files:
 try:
-self.checkFilePermission(file_data, peer_jid, perms_to_check, set_affiliation=True)
+self.checkFilePermission(
+file_data, peer_jid, perms_to_check, set_affiliation=True
+)
 except exceptions.PermissionError:
 to_remove.append(file_data)
 for file_data in to_remove:
 files.remove(file_data)
-defer.returnValue(files)
+return files
-@defer.inlineCallbacks
+async def setFile(
-def setFile(
 self, client, name, file_id=None, version="", parent=None, path=None,
 type_=C.FILE_TYPE_FILE, file_hash=None, hash_algo=None, size=None,
 namespace=None, mime_type=None, public_id=None, created=None, modified=None,
 owner=None, access=None, extra=None, peer_jid=None,
 perms_to_check=(C.ACCESS_PERM_WRITE,)
 owner = self.getFilesOwner(client, owner, peer_jid, file_id, parent)
 if path is not None:
 path = str(path)
 # _getParentDir will check permissions if peer_jid is set, so we use owner
-parent, remaining_path_elts = yield self._getParentDir(
+parent, remaining_path_elts = await self._getParentDir(
 client, path, parent, namespace, owner, owner, perms_to_check
 )
 # if remaining directories don't exist, we have to create them
 for new_dir in remaining_path_elts:
 new_dir_id = shortuuid.uuid()
-yield self.storage.setFile(
+await self.storage.setFile(
 client,
 name=new_dir,
 file_id=new_dir_id,
 version="",
 parent=parent,
 )
 parent = new_dir_id
 elif parent is None:
 parent = ""
-yield self.storage.setFile(
+await self.storage.setFile(
 client,
 file_id=file_id,
 version=version,
 parent=parent,
 type_=type_,

Mercurial > libervia-backend

comparison sat/memory/memory.py @ 3541:888109774673