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

comparison sat/memory/memory.py @ 3715:b9718216a1c0 0.9

merge bookmark 0.9

author	Goffi <goffi@goffi.org>
date	Wed, 01 Dec 2021 16:13:31 +0100
parents	71516731d0aa
children	001ea5f4a2f9

comparison

equal deleted inserted replaced

-:af09b5aaa5d7
+:b9718216a1c0
 from twisted.words.protocols.jabber import jid
 from sat.core.i18n import _
 from sat.core.log import getLogger
 from sat.core import exceptions
 from sat.core.constants import Const as C
-from sat.memory.sqlite import SqliteStorage
+from sat.memory.sqla import Storage
 from sat.memory.persistent import PersistentDict
 from sat.memory.params import Params
 from sat.memory.disco import Discovery
 from sat.memory.crypto import BlockCipher
 from sat.memory.crypto import PasswordHasher
 log.debug(
 "FIXME: PasswordSessions should ask for the profile password after the session expired"
 )
-class Memory(object):
+class Memory:
 """This class manage all the persistent information"""
 def __init__(self, host):
 log.info(_("Memory manager init"))
-self.initialized = defer.Deferred()
 self.host = host
 self._entities_cache = {}  # XXX: keep presence/last resource/other data in cache
 #     /!\ an entity is not necessarily in roster
 #     main key is bare jid, value is a dict
 #     where main key is resource, or None for bare jid
 self.subscriptions = {}
 self.auth_sessions = PasswordSessions()  # remember the authenticated profiles
 self.disco = Discovery(host)
 self.config = tools_config.parseMainConf(log_filenames=True)
 self._cache_path = Path(self.getConfig("", "local_dir"), C.CACHE_DIR)
-database_file = os.path.expanduser(
-os.path.join(self.getConfig("", "local_dir"), C.SAVEFILE_DATABASE)
+async def initialise(self):
-)
+self.storage = Storage()
-self.storage = SqliteStorage(database_file, host.version)
+await self.storage.initialise()
 PersistentDict.storage = self.storage
-self.params = Params(host, self.storage)
+self.params = Params(self.host, self.storage)
 log.info(_("Loading default params template"))
 self.params.load_default_params()
-d = self.storage.initialized.addCallback(lambda ignore: self.load())
+await self.load()
 self.memory_data = PersistentDict("memory")
-d.addCallback(lambda ignore: self.memory_data.load())
+await self.memory_data.load()
-d.addCallback(lambda ignore: self.disco.load())
+await self.disco.load()
-d.chainDeferred(self.initialized)
 ## Configuration ##
 def getConfig(self, section, name, default=None):
 """Get the main configuration option
 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 @ 3715:b9718216a1c0 0.9